多线程
本文共--字 阅读约--分钟 | 浏览: -- Last Updated: 2022-06-25
基本概念
程序、进程、线程
程序(program)是为完成特定任务、用某种语言编写的一组指令的集合，即指一段静态的代码。
进程(process)是程序的一次执行过程，或是正在运行中的一个程序，是一个动态的过程。有它自身的产生、生存和消亡的过程（生命周期）。
线程(thread)，进程可以进一步细化为线程，是一个程序内部的一条执行路径。
- 若一个进程同一时间并行执行多个线程，就是支持多线程的。
- 线程作为调度和执行的单位，每个线程都拥有独立的运行栈和程序计数器，线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
单核CPU和多核CPU
单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。
如果是多核的话，才能更好的发挥多线程的效率。
一个Java应用程序java.exe，至少有三个线程：main主线程、gc垃圾回收线程、异常处理线程。当然如果发生异常，会影响主线程。
并行与并发
并行是多个CPU同时执行多个任务，比如多个人同时做不同的事。 并发是一个CPU采用时间片轮转同时执行多个任务，比如抢票，多个人做同一件事。
使用多线程的优点
以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需要多线程呢？
多线程程序的优点：
1、提高应用程序的响应，对图形化界面更有意义，可增强用户体验。
2、提高计算机系统CPU的利用率
3、改善程序结构，将既长又复杂的进程分为多个线程，独立运行，利于理解和修改
何时需要多线程
-
程序需要同时执行两个或多个任务
-
程序需要实现一些需要等待的任务时，如用户输入，文件读写操作、网络操作、搜索等。
-
需要一些后台运行的程序时
线程的创建和启动
继承Thread类
/**
* 多线程的创建，方式一：继承于Thread类
*
* 1. 创建一个继承与Thread类的子类
* 2. 重写Thread类的run方法 -> 将此线程执行的操作声明在run中
* 3. 创建Thread类的子类的对象
* 4. 通过此对象调用start方法
*/
class MyThread extends Thread {
@Override
public void run() {
// 输出偶数
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
// 创建的线程的name是Thread-N
System.out.println(Thread.currentThread().getName() + "*******************" + i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
// 这是主线程
MyThread t = new MyThread();
t.start(); // 启动该线程；调用该线程的run方法
// t.run();
// 如果直接调用run方法，相当于创建了一个对象然后调用方法，run方法永远会在下面的输出之前输出
// 并且去查看当前是哪个线程时，会返回main，证明了如果直接调用run方法不会开启多个线程，仍然是主线程
// 哪个线程先执行是不确定的
// 以下的输出仍然是在主线程
System.out.println("hello");
// 在调用start方法后 不能再通过该线程对象调用start方法，否则会抛异常，除非创造多个线程对象
// 输出奇数
for (int i = 0; i < 10; i++) {
if (i % 2 != 0) {
// 主线程的name是main
System.out.println(Thread.currentThread().getName() + "*******************" + i);
}
}
}
}
创建Thread的匿名子类
public class ThreadTest2 {
public static void main(String[] args) {
// 创建Thread类的匿名子类的方式
new Thread() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "---通过匿名子类创建线程");
}
}.start();
}
}
Thread类常用的方法
1、start(): 启动当前线程，启用当前线程的run()方法
2、run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3、currentThread(): 静态方法，返回执行当前代码的线程
4、getName(): 获取当前线程的名字
5、setName(): 设置当前线程的名字，需要再start方法前设置，也可以修改主线程的线程名： Thread.currentThread().setName("主线程")，子类可以通过构造器来设置线程的名称 public MyThread(String name) { super(name); }
6、yield(): 释放当前cpu的执行权，但有可能下个执行又轮到该线程，会感觉没有释放一样。
7、join(): 在线程A中调用线程B的join方法，此时线程A就进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态。
8、stop(): 已过时，当执行此方法时，强制结束当前线程。
9、sleep(long millis): 让当前线程“睡眠”指定的毫秒时间，在指定时间内，当前线程是阻塞状态。
10、isAlive(): 判断当前线程是否存活
线程的优先级
1、线程的优先级等级
- MAX_PRIORITY: 10 最大
- MIN_PRIORITY: 1 最小
- NORM_PRIORITY: 5 通常 默认
2、涉及的方法
- getPriority(): 方法线程优先值
- setPriority(int newPriority): 改变线程的优先级
3、说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用，高优先级的线程要抢占低优先级线程cpu的执行权，但是只是从概率上讲，高优先级的线程高概率的情况下被执行，并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
实现Runnable接口
/**
* 创建多线程的方式二：实现Runnable接口
* 1. 创建一个实现了Runnable接口的类
* 2. 实现类去实现Runnable中的抽象方法run
* 3. 创建实现类的对象
* 4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
* 5. 通过Thread类的对象调用start
*/
class MyRunnable implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) System.out.println(i);
}
}
}
public class ThreadTest3 {
public static void main(String[] args) {
Thread t = new Thread(new MyRunnable());
t.start();
}
}
比较创建线程的两种方式：
1、开发中优先选择实现Runnable接口的方式，原因：
- 实现的方式没有类的单继承性的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况
2、联系
- Thread类也是实现的Runnable接口
- 两种方式都需要重写run方法，将线程的执行逻辑声明在run方法中。
实现Callable接口的方式 (JDK5.0新增)
1、创建一个实现Callable接口的实现类 2、实现call方法，将此线程需要执行的操作声明在call方法中 3、创建Callable接口实现类的对象 4、将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象 5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start方法 6、获取Callable中call方法的返回值（如果不需要其返回值此步骤可不用）
代码如下：
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
class NumThread implements Callable {
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
};
}
public class ThreadNew {
public static void main(String[] args) {
NumThread numThread = new NumThread();
FutureTask futureTask = new FutureTask(numThread);
// FutureTask实现了Runnable接口
new Thread(futureTask).start();
try {
// get方法的返回值即为FutureTask构造器参数Callback实现类重写的call方法的返回值
// 如果不需要使使用call方法的返回值 可以不用调get
Object sum = futureTask.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?
- call方法可以有返回值
- call方法可以抛出异常被外面的操作捕获，获取异常的信息
- Callable是支持泛型的
线程的生命周期
JDK中用Thread.State类定义了线程的几种状态，要想实现多线程，必须在主线程中创建新的线程对象。Java寓言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下五种状态：
新建(NEW)：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
就绪：处于新建状态的线程被start后，将进入线程队列等待CPU时间片，此时它已经具备了运行的条件，只是没分配到CPU资源。
运行(RUNNABLE)：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能。
阻塞(BLOCKED)：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。
死亡(TERMINATED)：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
线程的安全问题
问题出现的原因是：多个线程操作同一个共享数据，当某个线程操作的过程中，尚未操作完成时，其他线程也参与进来进行操作。
如何解决：当一个线程在操作的时候，使得其他线程不得参与进入，直到该线程操作完成。这种情况，即使该线程出现了阻塞不能被改变。
在Java通过同步机制来解决线程的安全问题。
同步代码块
操作共享数据的代码，即为需要被同步的代码
class Window1 implements Runnable {
private int ticket = 20;
Object obj = new Object();
@Override
public void run() {
while (true) {
// 参数是：同步监视器，俗称锁 任何对象都可以充当锁，但要求多个线程必须共用同一把锁，即锁也是"共享"的。
// 操作同步代码时，相当于只有一个线程参与，其他线程等待，等同于一个单线程，虽然解决了线程同步问题，但是效率低（局限）。
// 在实现Runnable接口的时候，这个obj可以考虑用this代替（如果this是唯一的），不需要另外声明
// synchronized (this) {}
synchronized (obj) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.start();
t2.start();
t3.start();
}
}
如果使用继承Thread的方式创建的多线程MyThread，需要给该锁变量加static，因为此时需要new出三个MyThread，那么声明在MyThread类里面的实例变量就不是唯一的了，而是每个实例对象都有一个。
class MyThread extends Thread {
// 共享数据要设置为static，不能声明为实例变量
private static int ticket = 20;
private static Object obj = new Object();
@Override
public void run() {
while (true) {
// 在继承Thread实现多线程的时候，这里的this通常是每个多线程的实例，所以要慎用this
// 但是可以使用MyThread.class代替
// synchronized (MyThread.class) {}
synchronized (obj) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
ticket--;
} else {
break;
}
}
}
}
}
public class WindowTest {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
}
}
同步方法
如果操作共享数据的代码完整的声明在一个方法中，不妨将此方法声明为同步的。
class Window2 implements Runnable {
private int ticket = 50;
@Override
public void run() {
while (true) {
sell();
}
}
private synchronized void sell() { // synchronized() 中默认使用的是this
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
ticket--;
}
}
// 如果你的run方法确实是可以全部提取出来的话，可以直接这样用
// public synchronized void run() {}
// 但是，在此例中，如果将while(true)包裹进来，那么将只有第一个到达的线程被使用，在同步代码块执行完成（while(true)跑完）之后才会"解开"锁。
// 后面的线程会一直等待，当while(true)执行完后，后面的线程才会进来，但此时票也被第一个抢占的线程卖完了
}
public class WindowTest2 {
public static void main(String[] args) {
Window2 w = new Window2();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.start();
t2.start();
t3.start();
}
}
如果使用继承Thread的方式创建的多线程MyThread的情况下，怎么使用同步方法来解决线程的安全问题？
class MyThread2 extends Thread {
private static int ticket = 50;
@Override
public void run() {
while (true) {
sell();
}
}
// 由于等同于 synchronized(this){}，但是使用继承Thread，每个多线程都是单独的实例，所有this不是唯一的
// 这个时候可以将这个方法声明为static来解决，此时的默认参数就不是this了，而是 MyThread2.class
private static synchronized void sell() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
ticket--;
}
}
}
public class WindowTest2 {
public static void main(String[] args) {
MyThread2 t1 = new MyThread2();
MyThread2 t2 = new MyThread2();
MyThread2 t3 = new MyThread2();
t1.start();
t2.start();
t3.start();
}
}
同步方法依然涉及到同步监视器，只是不需要我们显式的声明，非静态的同步方法的同步监视器是this，静态的同步方法的同步监视器丢下是当前类本身。
Lock锁(JDK5.0 新增)
import java.util.concurrent.locks.ReentrantLock;
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.start();
t2.start();
t3.start();
}
}
class Window implements Runnable {
private int ticket = 100;
// 1、实例化ReentrantLock
// 需要注意的是 要保证这个lock实例在多线程中是唯一的 在使用继承Thread创建多线程的时候要注意这一点
// ReentrantLock 构造函数有一个参数 fair，默认为false，如果为true则代表多线程之间的"抢权"是公平的
// 不会第一个线程进来之后执行完，然后下一次cpu选择又选择该线程，而是选择之前等待过的线程
private ReentrantLock lock = new ReentrantLock(true);
@Override
public void run() {
while(true) {
try {
// 2、调用锁定方法 等同于将下面的代码"锁"住 只有拿到的锁的线程才能进入执行 后面的线程要等待前面的线程释放该锁
lock.lock();
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "卖票：票号为" + ticket);
ticket--;
} else {
break;
}
} finally {
// 3、调用解锁方法
lock.unlock();
}
}
}
}
synchronized 和 lock 的区别在于，同步代码块/同步方法是等待同步代码执行完之后自动释放锁，而lock是要求手动启动和释放锁，比较灵活。
解决懒汉式单例模式的安全问题
class Bank {
private Bank() {};
private static Bank instance = null;
// 第一种方式：增加 synchronized 用同步方法可以解决单例模式不安全的情况
public static synchronized Bank getInstance() {
if (instance == null) {
// 当代码进入到这里然后走到最后的return时，有别的线程也调用了getInstance这个方法
// 此时instance还是为null，那么也会进入这里，然后创建一个新的实例，此时单例模式就不是安全的
// 可能会创建出多个实例
instance = new Bank();
}
return instance;
// 第二种方式: 同步代码块 但是效率稍差，因为当第一个线程进入之后，后面的线程就不应该在外面等着进入了应该直接return创建的实例
// synchronized (Bank.class) {
// if (instance == null) {
// instance = new Bank();
// }
// return instance;
// }
// 第二种方式：优化版
// 在外面加判断，是当第一个线程进入之后且创建好了实例之后，后面的多个线程再进入就不需要再进入同步代码块去排队了
// 但在第一个线程进入之后，且实例没有创建成功前，这个期间在第一个线程后面进入的线程也会等待
// 但对更后面（实例创建之后）的线程会表现的更好一点，不用再进入到同步代码块去排队了
// if (instance == null) {
// synchronized (Bank.class) {
// if (instance == null) {
// instance = new Bank();
// }
// }
// }
// return instance;
}
}
线程的死锁问题
死锁：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
解决方法：
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
死锁代码示例：
public class Deadlock {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread() {
@Override
public void run() {
synchronized (s1) {
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2) {
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
// 这个例子就是说明，当代码开始执行，上面的线程A开始执行，然后拿到s1的锁，然后sleep 100毫秒
// 此时下面的线程B也开始执行拿到了s2的锁 然后sleep 100毫秒
// 线程A sleep结束后在等待s2的释放，线程B也sleep结束后再等待s1的释放
// 但同时线程A因为代码块没有执行完成 拿着s1不释放，同时线程B也拿着s2不释放 就造成了死锁
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2) {
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1) {
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
线程的通信
场景：使用两个线程打印1-100，线程1和线程2交替打印
public class ThreadCommunicationTest {
public static void main(String[] args) {
Number n = new Number();
Thread t1 = new Thread(n);
Thread t2 = new Thread(n);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
class Number implements Runnable {
private int number = 1;
@Override
public void run() {
while (true) {
// 1、wait notify notifyAll 都需要在同步代码块或同步方法中的使用
// 默认都是通过this调用的 this. 被省略了
// 2、这三个方法的调用者必须是同步代码块或同步方法中的同步监视器，
// 所以如果 synchronized(obj){} obj为手动创建的具有唯一性的对象
// 那么调用这三个方法的时候要 obj.notify() 通过obj去调用
// 3、这三个方法是定义在java.lang.Object类中的，因为任何对象都可以充当同步监视器，所以这些方法必须在任意对象中都存在
synchronized (this) {
// notify(); // 2、唤醒阻塞(被wait)的一个线程，如果有多个线程被wait就唤醒优先级高的
notifyAll(); // 唤醒所有被wait的线程
if (number <= 100) {
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {
// 1、调用wait方法 会使当前线程进入阻塞状态，并释放同步监视器
// 会将线程1和线程2都打印完一次后都阻塞在这里
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
// 这个逻辑在于
// 线程1进入，然后拿到锁，调用notifyAll，此时没有线程被wait，不起作用，然后执行完打印，进行wait后释放锁
// 然后线程2进入，拿到进程1释放后的锁，调用notifyAll，此时就将wait的线程1唤醒
// 此时线程2拿着锁还没释放，线程1虽然被唤醒了也只能在外面等待，当线程执行完打印之后调用wait阻塞自己释放锁 线程1就得以进入
// 然后唤醒线程2，被唤醒的线程2执行完同步代码块之后也只能在外等待，因为此时锁在线程1手上，然后依次交替...
} else {
break;
}
}
}
}
}
sleep和wait的异同
1、相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2、不同点：
- 两个方法声明的位置不同：Thread类中声明sleep，Object类中声明wait。
- 调用的要求不同：sleep可以在任何需要的场景下调用，wait必须在同步代码块或同步方法中调用
- 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep不会释放锁，wait会释放锁。
使用线程池
经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
使用线程池的好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中的线程，不需要每次都创建）
- 便于线程管理
- corePoolSize: 核心池的大小
- maximumPoolSize: 最大线程数
- keepAliveTime: 线程没有任务时最多保持多长时间后会终止
- …
代码示例：
import java.util.concurrent.*;
/**
* Executors
*
* 1、提供指定线程数量的线程池
* 2、执行指定线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
*/
class NumberThread implements Runnable {
@Override
public void run() {
for (int i = 1; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
class NumberThread2 implements Callable {
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 1; i < 100; i++) {
if (i % 2 != 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
sum += i;
}
}
return sum;
};
}
public class ThreadPool {
public static void main(String[] args) {
ExecutorService pool = Executors.newFixedThreadPool(10);
// 设置线程池的属性 强转
ThreadPoolExecutor poolService = (ThreadPoolExecutor) pool;
poolService.setCorePoolSize(20);
pool.execute(new NumberThread()); // 适用于Runnable
ExecutorService pool2 = Executors.newFixedThreadPool(10);
Future<Integer> f = pool2.submit(new NumberThread2());// 适用于Callable
// 如果需要用到返回值
try {
Object sum = f.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
// 关闭线程池
pool.shutdown();
pool2.shutdown();
}
}