多线程
1、基础概念
1.1 多线程技术
- 从软件或者硬件上实现同时执行多个任务
- 具有多线程能拦的计算机因有硬件支持而能够在同一时间执行多个线程
- 多线程编程常常也将其称之为并发编程
1.2 并发和并行
1.3 进程和线程
- 进程：是正在运行的软件，且一个进程最少包括一个线程
- 独立性：进程是一个可以独立运行的基本单位，也是操作系统调度的最小单元，同时也是系统分配资源和调度的独立单位
- 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
- 并发性：任何进程都可以同其他进程一起并发执行
- 线程：是进程中的单个顺序控制流，是一条执行路径
- 单线程：一个进程如果只有一条执行路径，则称为单线程程序
- 多线程：一个程序如果有多条执行路径，则称为多线程程序
- 二者关系
- 线程是进程中的单个顺序控制流，是依赖于进程的，而一个进程最少包括一个线程，进程可以存在很多任务，每一个任务就是一个线程，这些执行路径之间没有任何的关联关系
2、线程的实现
2.1 继承Thread类
| 方法名 |
说明 |
| void run() |
在线程开启后，此方法将被调用执行 |
| void start() |
使此线程开始执行，Java虚拟机会调用run方法() |
- 实现步骤
- 定义一个类继承自Thread类，这里我们定义这个类为MyThread
- 重写Thread类中的run方法（run方法中重写的就是要被线程所执行的代码）
- 创建MyThread类的对象
- 启动线程（调用start方法）
- 注意：多线程的执行，具有随机性
- 代码实现
public class MyThread extends Thread { @Override public void run() { for(int i=0; i<100; i++) { System.out.println(i); } } } public class MyThreadDemo { public static void main(String[] args) { MyThread my1 = new MyThread(); MyThread my2 = new MyThread();
- 两个问题
- 为什么重写run方法
- run方法和start方法的区别
- run()：封装线程执行的代码，直接调用，相当于普通方法的调用
- start()：启动线程；然后由JVM调用此线程的run()方法
- start方法只能调用一次，如果调用多次程序将报错
2.2 实现Runnable接口
| 方法名 |
说明 |
| Thread(Runnable target) |
分配一个新的Thread对象 |
| Thread(Runnable target, String name) |
分配一个新的Thread对象 |
- 实现步骤
- 定义一个类实现Runnable接口，这里我们定义为MyRunnable
- 在MyRunnable类中重写run()方法
- 创建MyRunnable类的对象
- 创建Thread类的对象，把MyRunnable类对象作为构造方法的参数
- 启动线程
- 代码实现
public class MyRunnable implements Runnable { @Override public void run() { for(int i=0; i<100; i++) { System.out.println(Thread.currentThread().getName()+":"+i); } } } public class MyRunnableDemo { public static void main(String[] args) {
2.3 实现Callable类
| 方法名 |
说明 |
| V call() |
计算结果，如果无法计算结果，则抛出一个异常 |
| FutureTask(Callable callable) |
创建一个 FutureTask，一旦运行就执行给定的 Callable |
| V get() |
如有必要，等待计算完成，然后获取其结果 |
- 实现步骤
- 定义一个类实现Callable接口，这里我们将这个类定义为MyCallable
- 在MyCallable类中重写call（）方法
- 创建MyCallable类的对象
- 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
- 创建Thread类的对象，把FutureTask对象作为构造方法的参数
- 启动线程
- 调用get方法，就可以获取线程结束之后的结果
- 代码实现
public class MyCallable implements Callable<String> { @Override public String call() throws Exception { for (int i = 0; i < 100; i++) { System.out.println("跟女孩表白" + i); }
2.4 三种实现方式的区别
- 站在返回值的角度
- 继承Thread类和实现Runnable接口的方式没有返回值，获取不到线程执行的结果
- 实现Callable接口的方式有返回值，所以可以获取线程执行的结果
- 站在继承方式的角度
- 继承Thread类的方式，编程比较简单，可以直接使用Thread类的方法，但同时它的扩展性相对较弱
- 实现Runnable或Callable接口，因为在Java中一个类可以实现多个接口，因此扩展性较高，但同时编程相对复杂，不能直接使用Thread类中的方法
3、Thread类的API
| 方法名 |
说明 |
| void setName(String name) |
设置线程名称 |
| public final String getName( ) |
获取线程名称 |
| Thread currentThread() |
返回对当前正在执行的线程对象的引用 |
public class MyThread extends Thread { public MyThread() {} public MyThread(String name) { super(name); } @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName()+":"+i); } } } public class MyThreadDemo { public static void main(String[] args) { MyThread my1 = new MyThread(); MyThread my2 = new MyThread();
3.2 线程休眠
| 方法名 |
说明 |
| static native void sleep (long millis) |
使当前正在执行的线程停留（暂停执行）指定的毫秒数 |
public class MyRunnable implements Runnable { @Override public void run() { for (int i = 0; i < 100; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "---" + i); } } } public class Demo { public static void main(String[] args) throws InterruptedException {
3.3 线程优先级
3.3.1 线程调度
- 两种调度方式
- 分时调度模型
- 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片
- 抢占式调度模型
- 优先级高的线程优先使用CPU，如果优先级相同，那么随机选择一个，优先级高的线程获取的CPU时间片相对多一些
- JAVA使用的是抢占式调度模型
- 随机性
- 假如计算机只有一个CPU ，那么某一时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是随机性的，因为谁抢到CPU的使用权是不一定的
3.3.2 相关方法
| 方法名 |
说明 |
| final int getPriority() |
返回此线程的优先级 |
| final void setPriority(int newPriority) |
更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10 |
public class MyCallable implements Callable<String> { @Override public String call() throws Exception { for (int i = 0; i < 100; i++) { System.out.println(Thread.currentThread().getName() + "---" + i); } return "线程执行完毕了"; } } public class Demo { public static void main(String[] args) {
3.4 守护线程
- Java语言中的线程可以分为普通线程和守护线程
- 守护线程的作用
- 为普通线程服务，如果普通线程结束，守护线程也会结束
- JVM会检查线程的类型，如果当前的JVM进程中所有的线程都是守护线程，Jvm停止运行。
- 相关方法
| 方法名 |
说明 |
| void setDaemon(boolean on) |
将此线程标记为守护线程 |
public class MyThread1 extends Thread { @Override public void run() { for (int i = 0; i < 10; i++) { System.out.println(getName() + "---" + i); } } } public class MyThread2 extends Thread { @Override public void run() { for (int i = 0; i < 100; i++) { System.out.println(getName() + "---" + i); } } } public class Demo { public static void main(String[] args) { MyThread1 t1 = new MyThread1(); MyThread2 t2 = new MyThread2(); t1.setName("女神"); t2.setName("备胎");
4、线程安全问题
4.1 数据安全问题
- 安全问题出现的条件
- 如何解决多线程安全问题
- 基本思想
- 如何实现
- 把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可
- 锁在Java中存在两种
- 内部锁的实现
- 显式锁
4.2 同步代码块
- 格式
- synchronized(任意对象) { 多条语句操作共享数据的代码 }
- synchronized(任意对象）
- 同步的好处和弊端
- 好处
- 弊端
- 当线程很多时，因为每个线程都会判断同步上的锁，这会很耗费资源，降低程序运行效率
- 代码实现
public class SellTicket implements Runnable { private int tickets = 100; private Object obj = new Object(); @Override public void run() { while (true) { synchronized (obj) {
4.3 同步方法
- 同步方法
- 格式
- 修饰符 synchronized 返回值类型 方法名(方法参数) { 方法体；}
- 同步方法的锁对象
- 同步静态方法
- 修饰符 static synchronized 返回值类型 方法名(方法参数) { 方法体；}
- 同步静态方法的锁对象
- 代码实现
public class Demo { public static void main(String[] args) { MyRunnable mr = new MyRunnable(); Thread t1 = new Thread(mr); Thread t2 = new Thread(mr); t1.setName("窗口一"); t2.setName("窗口二"); t1.start(); t2.start(); } } class MyRunnable implements Runnable { private static int ticketCount = 100; @Override public void run() { while(true){ if("窗口一".equals(Thread.currentThread().getName())){
