这里写目录标题
什么是多线程
在学习多线程之前,先让我们明白什么是进程,什么是线程
进程是一个内存中运行的应用程序,每个进程都有一个独立的内存空间
而线程,是指进程中的一个执行路径,共享一个内存空间,线程之间可以自由切换,并发执行. 一个进程最少 有一个线程
线程实际上是在进程基础之上的进一步划分,一个进程启动之后,里面的若干执行路径又可以划分 成若干个线程
打开你电脑的任务管理,你就能看到你目前执行的线程和进程的数量
在之前我们所有的编程都是单线程的,即仅有main线程,程序运行的顺序是从头到尾;而当我们学习玩多线程后,我们能够并发的执行多个线程,以达到一些我们需要的功能。
多线程相关概念
调度
目前我们电脑的CPU通常有多核,其中的每一个核,都只能运行单一的线程,为了在不提升运算速率(指处理单个线程的时间)的情况下,提高CPU运算的效率,就必须对合理的调度线程(对于单核而言,并不能提升)
线程的调度,即是对线程运行的调配。在一个进程中,通常所有线程不会一起运行,而是根据需要分次分时的运行,为了能够合理的调度线程,我们有两种基础调度模型:
分时调度:
所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间
抢占式调度:
JVM采用的就是抢占式调度,当CPU空闲后,各个线程会开始争抢运行机会,高优先级的线程会更容易抢到运行机会(注意并不是一定抢到)
同步和异步
在我们之前学习常用类库时,我们就提到过同步和异步的概念,现在让我们详细了解一下:
同步(synchronize)-线程排队执行,效率低,但是线程安全
异步(asynchronize)-线程同时执行,效率搞,但是线程不安全
想象一下有一个卖汉堡的汉堡店,同时有几个人一起来买汉堡吃
同步即是几个人排队买汉堡,虽然吃得慢,但是每个人都能安全的吃,如果店家一次能做两个汉堡,则两个人就能一起吃
异步则是围在一起等着吃,当一个人想吃某个汉堡的时候,可能这个汉堡已经被另一个人吃掉了,但是他并不知情,只能打开汉堡盒吃空气,这就是线程不安全(另一个线程篡改了公共的数据,但是执行的线程并不知情)
并发和并行
并发:指两个或多个事件在同一个时间段内发生
并行:指两个或多个事件在同一时刻发生(同时发生,平行发生)
守护线程
之前我们提到过,一个进程通常包括多个线程,至少包括一个线程
当所有的线程全部结束后,一个进程也就自然而然的结束了
线程在其中又可以被分为用户线程和守护线程,守护线程在运行时跟用户线程没有区别,但是如果所有用户线程都结束了,守护线程会自行结束
JVM中一直被我们提到的GC就是一个守护线程,当没有用户线程运行时,GC也会自动结束
多线程编程
学习了那么多概念,现在让我们正式开始学习一下多线程编程,Java中,多线程编程主要通过两种方法实现:
继承Thread类
自行编写一个类并继承Thread类,并且重写其中的run方法,创建该类的对象,调用start方法就能达到多线程的效果,下面让我们看一个简单的例子:
public class multithread {
public static void main(String[] args) {
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
MyThread myThread3 = new MyThread();
myThread1.start();
myThread2.start();
myThread3.start();
}
}
class MyThread extends Thread{
@Override
public void run(){
for(int i=0; i<5; i++)
System.out.print(i);
}
}
在MyThread类中我们重写了run方法,然后在main方法中创建了三个MyThread类的对象,并且一一调用start方法
运行结果可能是:
012340123401234
001234012341234
010123401234234
001234123401234
这正是因为这几个线程拥有相同的优先级,他们不断的抢占运行机会,所以会产生不同的运行结果
实现Runnable接口
实现Runnable接口同样需要重写run方法,但是调用的方法略微有点不同:
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();
或者
new Thread(new MyRunnable()).start();
Thread和Runnable比较:
- Runnable更适用于多个线程执行相同的任务,任务和线程分离,健壮性(robustness)更强
- Runnable可以避免单继承的缺陷,即在实现Runnable后还可以继承其他类
- 线程池仅适用于Runnable
但是Thread也有非常好用的地方,比如:
new MyThread().start();
// 通过匿名类快速执行线程
甚至直接使用内部类创建并执行线程:
new Thread(){
@Override
public void run(){
for(int i=0; i<5; i++)
System.out.print(i);
}
}.start();
Thread类详解
无论使用哪种多线程编程,都需要使用Thread类,现在让我们详细学习一下Thread类
首先Thread类有四种常用的构造方法:
Thread();
Thread(Runnable target);
Thread(Runnable target, String name);
Thread(String name);
还有一些我们需要关注的方法:
static void sleep(long milis);// 休眠,单位为毫秒
static void sleep(long milis, int nanos);// 后为纳秒
String getName();// 返回线程的名字(构造时传入)
也可以使用Thread.currentThread().getName();获取名字
void setName(String name);// 设置线程名字
void setDaemon(boolean on);// 设置是否为守护线程
long getId();// 返回线程的ID(标识符)
void setPriority(int newPriority);// 设置优先级
int getPriority();// 返回优先级值
优先级即是我们之前提到过的运行优先级,拥有高优先级的线程会有更高的几率抢到运行,在Java中,最高优先级为10,最低为1,默认为5
void stop();
在目前版本的JDK中,stop是一个已经被汰换的方法,因为使用stop会很容易导致死锁,目前结束线程通常在run方法中写明条件,达到条件后自行结束
Thread中还含有一个内部类State,该类用于指明线程的状态
在其中,线程被分为六种状态,New-刚创建还未启动,Runnable-正在执行,Blocked-被阻塞等待其他线程(即排队中),Waiting-无限期等待(休眠),TimeWaiting-计时等待,Terminated-被终止,已退出竞争
线程问题
线程的结束
一个线程是一个独立的执行路径,注意我们刚刚提到过,一个线程想要结束,最好通过条件让它自行结束,而不是使用stop方法
这时我们就需要使用标识符的方法
public class multithread {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
t1.start();
t1.interrupt();
}
}
class MyRunnable implements Runnable{
@Override
public void run() {
for(int i=0; i<10; i++) {
System.out.print(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
//e.printStackTrace();
System.out.println(1);
}
}
}
}
注意这里的interrupt方法并不是结束这个进程,而是让这个进程执行sleep方法时抛出异常,如果你像这样将异常注释掉,线程也会默默的运行到结束,或者在catch中写上return;,这样线程会立即结束却不报错
线程安全问题
之前我们提到过线程安全问题,现在让我们详细解释一下
同样使用汉堡店的例子,三个人来到汉堡店,但是店家不做汉堡了,目前只有十个汉堡,让我们用抢占式调度完成一下该代码:
public class multithread {
public static void main(String[] args) {
MyRunnable myRunnable = new MyRunnable();
Thread t1 = new Thread(myRunnable);
Thread t2 = new Thread(myRunnable);
Thread t3 = new Thread(myRunnable);
t1.start();
t2.start();
t3.start();
}
}
class MyRunnable implements Runnable{
int count = 10;
@Override
public void run() {
int i = 0;
while(count > 0) {
count--;
i++;
System.out.println(Thread.currentThread().getName()+":"+i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
从逻辑上来看,整段代码没有任何问题,但是当我们运行后,却发现结果:
Thread-1:4
Thread-0:4
Thread-2:5
Process finished with exit code 0
三个人总共竟然买到了13个汉堡,这就是线程不安全的问题,如果一个线程在另一个线程将count减到0之前进行了判断,那么该线程仍然会继续执行,最终导致count变成了负数
处理线程安全问题
为了解决线程安全问题,Java提出了多种解决方案,他们都采用了加锁的机制,即在一个线程执行时通过锁定其他线程,使整体执行变得同步
同步代码块
在第八讲中我们就提到过同步代码块的概念,现在让我们学习一下同步代码块
同步代码块通过如下方式定义
synchronized (对象名){
}
让我们用同步代码块更新一下原先的汉堡店代码:
class MyRunnable implements Runnable{
int count = 10;
Object obj = new Object();
@Override
public void run() {
int i = 0;
while(true) {
synchronized (obj) {// 普通的公共对象
if(count > 0) {
count--;
i++;
System.out.println(Thread.currentThread().getName() + ":" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else
break;// 不然无法结束进程
}
}
}
注意其中的obj只是一个公共的Object对象(必须是公共的)
使用这种方法,能够保证三个顾客总共只能买到10个汉堡,但是同步代码块也有一些问题:
- 效率大幅降低
- 必须为了同步更改代码结构
- 很容易出现一个线程连续运行的情况
同步方法
同步方法即把synchronize关键字修饰到方法上,此时MyRunnable方法就需要改为:
class MyRunnable implements Runnable{
int count = 10;
@Override
public void run() {
while(true)
if(!sale())
break;
}
public synchronized boolean sale(){
if(count > 0) {
count--;
System.out.println(Thread.currentThread().getName() + "购买了一个汉堡");
System.out.println("汉堡余量:"+count);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
return true;
}
return false;
}
}
相较于同步代码块,同步方法的锁更加不精密
显式锁
在之前我们使用的同步代码块和同步方法都是隐式锁,可以发现整体代码中没有提到过锁,加锁和开锁,而我们现在将要直接使用锁Lock类
Lock lock1 = new ReentrantLock();// 创建锁
lock1.lock();// 加锁
lock1.unlock();// 解锁
它的使用也很直接,可以直接把锁套用在同步代码块的两个大括号处
public void run() {
int i = 0;
while(true) {
lock1.lock();
if(count > 0) {
count--;
i++;
System.out.println(Thread.currentThread().getName() + ":" + i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else
break;
lock1.unlock();
}
}
为了能让程序正常结束我们还需要在else中添加解锁操作
else {
lock1.unlock();
break;
}
显式锁和隐式锁各有所长,比如显式锁是通过API完成加锁效果的,而隐式锁则是在JVM层面的;显式锁可以对锁进行分组,达到精确唤醒的目的,也可以自己决定是不是公平锁,还可以自行中断,但是Java官方明显还是更偏向于隐式锁,不仅更新不断,官方帮助文档里的描述也是写的满满当当,生怕你看不懂。
公平锁
公平锁的概念即为一个锁解开时,其他线程抢夺是否公平
如果是公平的,那么在锁还没解开是,等待锁解开的线程就开始排队等候,一个个的使用
而不公平的则是锁一旦解开,所有的线程都会同时抢夺该锁
隐式锁和显式锁默认都是非公平的,但是在显式锁的创建时,可以传入一个true参数,来创建一个公平锁
死锁
死锁的概念很简单,正如死结一样,无法通过正常手段解开,一个死锁的产生可以很复杂,也可以很简单(至少需要两个锁)
死锁的概念可以通过一个简单的例子来阐明:一条窄道上有两个英国绅士,绅士们很讲究绅士风度,所以当遇到迎面而来的人时,他们都会让出路来让对面先走
很明显,会产生的结果是,两位绅士都会接连后退,等待对方先过,最后谁也过不去,这就相当于产生了死锁
线程池
如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程 就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间.
线程池就是一个容纳多个线程的容器,在系统启动时即创建大量空闲的线程,程序将一个任务传给线程池,线程池就会启动一条线程来执行这个任务,执行结束以后,该线程并不会死亡,而是再次返回线程池中成为空闲状态,等待执行下一个任务
池中的线程可以反复使用,省去了频繁创建线程对象的操作,降低了资源的消耗,提高了相应速度,还提高了线程的可管理性
Java中有四种线程池,而四种线程池都通过ExecutorServie来实现,让我们一一学习:
缓存线程池
缓存线程池执行流程为:
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在,则创建线程并放入线程池, 然后使用
缓存线程池的长度可以按需不断的延申,没有长度的限制
构建缓存线程池的方法是
ExecutorService service = Executors.newCachedThreadPool();
service.execute(new MyRunnable());
定长线程池
定长线程池执行流程为:
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程 并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
定长线程池就相当于长度固定的缓存线程池
定长线程池构建方法是:
ExecutorService service = Executors.newFixedThreadPool(2); // 传入长度
service.execute(new MyRunnable());
单线程线程池
单线程线程池执行流程为:
- 判断线程池中的唯一线程是否空闲
- 空闲则使用
- 不空闲,则等待该线程空闲后使用
单线程线程池就相当于定长为1的定长线程池
单线程线程池构建方法为:
ExecutorService service = Executors.newSingleThreadExecutor();
service.execute(new MyRunnable());
周期性任务定长线程池
周期性任务定长线程池执行流程为:
- 判断线程池是否存在空闲线程
- 存在则使用
- 不存在空闲线程,且线程池未满的情况下,则创建线程并放入线程池, 然后使用
- 不存在空闲线程,且线程池已满的情况下,则等待线程池存在空闲线程
周期性任务定长线程池根据定时和周期有两种构建方法:
ScheduledExecutorService service = Executors.newScheduledThreadPool(2);// 长度
// 定时执行
service.schedule(new MyRunnable() , 5,TimeUnit.SECONDS);
// 其中第二个参数为时长数字,第三个参数为时长数字的单位,上面代码结果即该线程五秒钟执行一次
// 周期执行
service.scheduleAtFixedRate(new Runnable() ,5,1,TimeUnit.SECONDS);
// 其中二参为第一次执行在多久以后,三参四参同上,上面代码结构即5秒之后每一秒执行一次
多线程通信
多线程通信需要了解四个在Object类中的方法:
void notify();// 随机唤醒某线程
void notifyAll();// 唤醒所有线程
void wait();// 等待,不唤醒则一直等
void wait(long timeoutMilis);// 等待,指定时间
多线程通信中有一个很经典的问题,叫做生产者与消费者问题,也叫做PV操作问题(其中涉及到信号量的问题,但是暂时不用理解),设想刚刚的汉堡店,汉堡店做一个,顾客才能买来吃
让我们用代码来实现一下:
public class multithread {
public static void main(String[] args) {
ProcessSynchronization ps = new ProcessSynchronization();
new Thread(new Producer(ps)).start();
new Thread(new Producer(ps)).start();
new Thread(new Producer(ps)).start();
new Thread(new Consumer(ps)).start();
new Thread(new Consumer(ps)).start();
new Thread(new Consumer(ps)).start();
}
}
//生产者类
class Producer implements Runnable{
ProcessSynchronization ps = new ProcessSynchronization();
Producer(ProcessSynchronization ps){
this.ps = ps;
}
public void run(){
while(true){
try {
this.ps.produce();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者类
class Consumer implements Runnable{
ProcessSynchronization ps = new ProcessSynchronization();
Consumer(ProcessSynchronization ps){
this.ps = ps;
}
public void run(){
while(true){
try {
this.ps.consume();
}catch(Exception e) {
e.printStackTrace();
}
}
}
}
class ProcessSynchronization{
int count = 0;
public synchronized void produce() throws InterruptedException {
Thread.sleep(500);
if (count<10) {
count++;
System.out.println("制造了一个小汉堡,现在余量:" + count);
super.notifyAll();
} else
super.wait();
}
public synchronized void consume() throws InterruptedException {
Thread.sleep(500);
if(count>0) {
count--;
System.out.println("吃掉了一个小汉堡,现在余量:" + count);
super.notifyAll();
} else
super.wait();
}
}
这段代码运行后,就会一直有新的小汉堡被制造,也会一直有顾客吃掉小汉堡
本段代码的难度比较大,如果实在不能理解可以暂时搁置
Callable接口和Lambda
在主流的两种线程创建方法之外,还可以通过实现Callable接口创建线程
Callable的使用比较复杂:
class XXX implements Callable<T> {
@Override
public <T> call() throws Exception {
return T;
}
}// 首先创建类实现,其中T为泛型
MyCallable myCallable = new MyCallable();
FutureTask<String> futureTask = new FutureTask<String>(myCallable);// 这里的String就是类中泛型
Thread thread = new Thread(futureTask);
thread.start();// 一步步构建,最终还是使用Thread类
可以使用futureTask.get();方法或者isDone();方法,等待该对象的线程完成之后再继续执行下去
Callable并不是很经常使用,但是在早期Runnable接口功能不完善时经常被使用,学习该接口有助于阅读源码
学完Runnable和Callable后你可能感觉,创建一个线程也太麻烦了,完整的创建需要创建两三个对象,其实线程中的输出语句就一句,但是为了执行该语句要写很多的结构代码
Java为了提高效率,提出了Lambda表示式,可以省略所有无实际意义的结构代码,很大幅的节约代码量,Lambda表达式通过如下方式使用
Thread thread = new Thread(() -> System.out.println(1));
thread.start();
这一行代码就相当于构建了线程代码,创建了线程并执行,而Lambda表达式其实也可以应用于任何情况,并不是线程的专属,使用Lambda表达式其实就是省略了一个创建内部类的内容
在编程中通常不提倡大量使用Lambda表达式,因为其会对debug的过程带来很多麻烦,虽然整体看起来简洁,但实际上让后续的更改更加麻烦