了解

简单了解多线程

是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，提升性能。

简单了解多线程

概念

线程相关的概念

并行：在同一时刻，有多个指令在多个CPU上同时执行。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并发和并行

并行：在同一时刻，有多个指令在多个CPU上同时执行。

并发和并行

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并发和并行

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并发和并行

并发：在同一时刻，有多个指令在单个CPU上交替执行。

进程和线程

进程：是正在运行的软件

独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位。

动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的。

并发性：任何进程都可以同其他进程一起并发执行

进程和线程

线程：是进程中的单个顺序控制流，是一条执行路径。

进程和线程

线程：是进程中的单个顺序控制流，是一条执行路径。

单线程：一个进程如果只有一条执行路径，则称为单线程程序

多线程：一个进程如果有多条执行路径，则称为多线程程序

小结

并发和并行

并行：在同一时刻，有多个指令在多个CPU上同时执行。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

进程和线程

进程：就是操作系统中正在运行的一个应用程序。

线程：就是应用程序中做的事情。比如：360软件中的杀毒，扫描木马，清理垃圾。

实现方式

多线程的实现方式

多线程的实现方案

继承Thread类的方式进行实现

实现Runnable接口的方式进行实现

利用Callable和Future接口方式实现

package com.itheima.threaddemo1;public class MyThread extends Thread{@Overridepublic void run() {//代码就是线程在开启之后执行的代码for (int i = 0; i < 100; i++) {System.out.println("线程开启了" + i);}}
}package com.itheima.threaddemo1;public class Demo {public static void main(String[] args) {//创建一个线程对象MyThread t1 = new MyThread();//创建一个线程对象MyThread t2 = new MyThread();//t1.run();//表示的仅仅是创建对象,用对象去调用方法,并没有开启线程.//t2.run();//开启一条线程t1.start();//开启第二条线程t2.start();}
}

线程开启了90
线程开启了99
线程开启了91
线程开启了92
线程开启了93
线程开启了94
线程开启了95
线程开启了96
线程开启了97
线程开启了98
线程开启了99Process finished with exit code 0

方案1：继承Thread类

定义一个类MyThread继承Thread类

在MyThread类中重写run()方法

创建MyThread类的对象

启动线程(如上)

两个小问题：

为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用，并没有开启线程。 start()：启动线程；然后由JVM调用此线程的run()方法

多线程的实现方式

方式2：实现Runnable接口

定义一个类MyRunnable实现Runnable接口

在MyRunnable类中重写run()方法

创建MyRunnable类的对象

创建Thread类的对象，把MyRunnable对象作为构造方法的参数启动线程

package com.itheima.threaddemo2;public class MyRunnable implements Runnable{@Overridepublic void run() {//线程启动后执行的代码for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "第二种方式实现多线程" + i);}}
}

测试类:

package com.itheima.threaddemo2;public class Demo {public static void main(String[] args) {//创建了一个参数的对象MyRunnable mr = new MyRunnable();//创建了一个线程对象,并把参数传递给这个线程.//在线程启动之后,执行的就是参数里面的run方法Thread t1 = new Thread(mr);//开启线程t1.start();MyRunnable mr2 = new MyRunnable();Thread t2 = new Thread(mr2);t2.start();}
}

Thread-0第二种方式实现多线程96
Thread-1第二种方式实现多线程96
Thread-0第二种方式实现多线程97
Thread-1第二种方式实现多线程97
Thread-0第二种方式实现多线程98
Thread-1第二种方式实现多线程98
Thread-0第二种方式实现多线程99
Thread-1第二种方式实现多线程99Process finished with exit code 0

方式3：Callable和Future

定义一个类MyCallable实现Callable接口

在MyCallable类中重写call()方法创建MyCallable类的对象

创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数

创建Thread类的对象，把FutureTask对象作为构造方法的参数

启动线程

再调用get方法，就可以获取线程结束之后的结果。

package com.itheima.threaddemo3;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {for (int i = 0; i < 100; i++) {System.out.println("跟女孩表白" + i);}//返回值就表示线程运行完毕之后的结果return "答应";}
}

测试类:

package com.itheima.threaddemo3;import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;public class Demo {public static void main(String[] args) throws ExecutionException, InterruptedException {//线程开启之后需要执行里面的call方法MyCallable mc = new MyCallable();//Thread t1 = new Thread(mc);//可以获取线程执行完毕之后的结果.也可以作为参数传递给Thread对象FutureTask<String> ft = new FutureTask<>(mc);//创建线程对象Thread t1 = new Thread(ft);String s = ft.get();//开启线程t1.start();//String s = ft.get();System.out.println(s);}
}

正确的代码:

  public static void main(String[] args) throws ExecutionException, InterruptedException {//String s = ft.get();//开启线程t1.start();String s = ft.get();System.out.println(s);}

三种方式的对比

优点

缺点

实现Runnable、

Callable接口

扩展性强，实现该接口的同时还可以继承其他的类。

编程相对复杂，不能直接使用Thread类中的方法

继承Thread类

编程比较简单，可以直接使用Thread类中的方法

可以扩展性较差，

不能再继承其他的类

常见方法

线程类的常见方法

获取和设置线程名称

获取线程的名字

String getName()：返回此线程的名称

Thread类中设置线程的名字

void setName(String name)：将此线程的名称更改为等于参数 name

通过构造方法也可以设置线程名称

package com.itheima.threaddemo4;public class MyThread extends Thread {public MyThread() {}public MyThread(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + "@@@" + i);}}
}

测试类:

package com.itheima.threaddemo4;public class Demo {//1,线程是有默认名字的,格式:Thread-编号public static void main(String[] args) {MyThread t1 = new MyThread("小蔡");MyThread t2 = new MyThread("小强");//t1.setName("小蔡");//t2.setName("小强");t1.start();t2.start();}
}

小强@@@97
小蔡@@@98
小强@@@98
小蔡@@@99
小强@@@99Process finished with exit code 0

获得当前线程的对象

public static Thread currentThread()：返回对当前正在执行的线程对象的引用

package com.itheima.threaddemo5;public class Demo {public static void main(String[] args) {String name = Thread.currentThread().getName();System.out.println(name);}
}

线程休眠

public static void sleep(long time)：让线程休眠指定的时间，单位为毫秒。

package com.itheima.threaddemo6;public class MyRunnable implements Runnable {@Overridepublic 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);}}
}

测试类:(获取线程,休眠,获取名称)

package com.itheima.threaddemo6;public class Demo {public static void main(String[] args) throws InterruptedException {/*System.out.println("睡觉前");Thread.sleep(3000);System.out.println("睡醒了");*/MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);t1.start();t2.start();}
}

Thread-0---97
Thread-1---98
Thread-0---98
Thread-0---99
Thread-1---99Process finished with exit code 0

线程调度

多线程的并发运行：

计算机中的CPU，在任意时刻只能执行一条机器指令。每个线程只有获得CPU的使用权才能执行代码。

各个线程轮流获得CPU的使用权，分别执行各自的任务。

线程有两种调度模型

分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程

获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

CPU

线程的优先级

public final void setPriority(int newPriority) 设置线程的优先级

public final int getPriority() 获取线程的优先级

package com.itheima.threaddemo7;import java.util.concurrent.Callable;public class MyCallable implements Callable<String> {@Overridepublic String call() throws Exception {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName() + "---" + i);}return "线程执行完毕了";}
}

import java.util.concurrent.FutureTask;public class Demo {public static void main(String[] args) {//优先级: 1 - 10 默认值:5MyCallable mc = new MyCallable();FutureTask<String> ft = new FutureTask<>(mc);Thread t1 = new Thread(ft);t1.setName("飞机");t1.setPriority(10);//System.out.println(t1.getPriority());//5t1.start();MyCallable mc2 = new MyCallable();FutureTask<String> ft2 = new FutureTask<>(mc2);Thread t2 = new Thread(ft2);t2.setName("坦克");t2.setPriority(1);//System.out.println(t2.getPriority());//5t2.start();}
}

后台线程/守护线程

public final void setDaemon(boolean on)：设置为守护线程

package com.itheima.threaddemo8;public class MyThread1 extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "---" + i);}}
}

package com.itheima.threaddemo8;public class MyThread2 extends Thread {@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(getName() + "---" + i);}}
}

package com.itheima.threaddemo8;public class Demo {public static void main(String[] args) {MyThread1 t1 = new MyThread1();MyThread2 t2 = new MyThread2();t1.setName("女神");t2.setName("备胎");//把第二个线程设置为守护线程//当普通线程执行完之后,那么守护线程也没有继续运行下去的必要了.t2.setDaemon(true);t1.start();t2.start();}
}

女神---8
备胎---8
女神---9
备胎---9
备胎---10
备胎---11
备胎---12
备胎---13
Process finished with exit code 0

线程生命周期

安全问题

线程的安全问题

需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票

思路：

①定义一个类Ticket实现Runnable接口，里面定义一个成员变量：private int ticketCount = 100;

② 在Ticket类中重写run()方法实现卖票，代码步骤如下

A：判断票数大于0，就卖票，并告知是哪个窗口卖的

B：票数要减1

C：卖光之后，线程停止

③ 定义一个测试类TicketDemo，里面有main方法，代码步骤如下

A：创建Ticket类的对象

B：创建三个Thread类的对象，把Ticket对象作为构造方法的参数，并给出对应的窗口名称

C：启动线程

package com.itheima.threaddemo9;public class Ticket implements Runnable {//票的数量private int ticket = 100;private Object obj = new Object();@Overridepublic void run() {while(true){synchronized (obj){//多个线程必须使用同一把锁.if(ticket <= 0){//卖完了break;}else{try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}ticket--;System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");}}}}
}

package com.itheima.threaddemo9;public class Demo {public static void main(String[] args) {/*Ticket ticket1 = new Ticket();Ticket ticket2 = new Ticket();Ticket ticket3 = new Ticket();Thread t1 = new Thread(ticket1);Thread t2 = new Thread(ticket2);Thread t3 = new Thread(ticket3);*/Ticket ticket = new Ticket();Thread t1 = new Thread(ticket);Thread t2 = new Thread(ticket);Thread t3 = new Thread(ticket);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");t1.start();t2.start();t3.start();}
}

改造:

    @Overridepublic void run() {while (true) {// 当前这个this表示的是Ticket的票对象,我们在测试类中创建了几个票对象?// 答: 1个,所以能保证多个线程使用的是同一个锁对象synchronized (this){if (ticket <= 0) {//卖完了break;} else {System.out.println(Thread.currentThread().getName() + "正在卖" + ticket + "号票");ticket--;}}}}

卖票案例的思考

刚才讲解了电影院卖票程序，好像没有什么问题。但是在实际生活中，售票时出票也是需要时间的，所以，在出售一张票的时候，需要一点时间的延迟，接下来我们去修改卖票程序中卖票的动作：每次出票时间100毫秒，用sleep()方法实现

卖票出现了问题

相同的票出现了多次

出现了负数的票

问题原因：

线程执行的随机性导致的

卖票案例数据安全问题的解决

卖票案例数据安全问题的解决

为什么出现问题?(这也是我们判断多线程程序是否会有数据安全问题的标准)

多线程操作共享数据

如何解决多线程安全问题呢?

基本思想：让程序没有安全问题的环境

怎么实现呢?

把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可

Java提供了同步代码块的方式来解决

同步代码块

锁多条语句操作共享数据，可以使用[同步代码块]实现

格式：

synchronized(任意对象) {

多条语句操作共享数据的代码

}

使用 Runnable就可以了

默认情况是打开的，只要有一个线程进去执行代码了，锁就会关闭

当线程执行完出来了，锁才会自动打开

同步的好处和弊端

好处：解决了多线程的数据安全问题

弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

同步方法

同步方法：就是把synchronized关键字加到方法上

格式：

修饰符 synchronized 返回值类型方法名(方法参数) { }

同步代码块和同步方法的区别:

同步代码块可以锁住指定代码,同步方法是锁住方法中所有代码

同步代码块可以指定锁对象,同步方法不能指定锁对象

同步方法的锁对象是什么呢?

this

package com.itheima.threaddemo011;
/*任务类,将来只会创建一个任务类对象,可以由多个线程,共同执行这个任务对象*/
public class MyRunnable implements Runnable {private static int ticketCount = 100;@Overridepublic void run() {// 希望通过这个run方法,获知当前是哪个线程正在执行任务,从而决定以什么方式保证数据安全;while(true){if("窗口一".equals(Thread.currentThread().getName())){//同步方法boolean result = synchronizedMthod();if(result){break;}}if("窗口二".equals(Thread.currentThread().getName())){//同步代码块synchronized (MyRunnable.class){if(ticketCount == 0){break;}else{try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}ticketCount--;System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");}}}}}private static synchronized boolean synchronizedMthod() {if(ticketCount == 0){return true;}else{try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}ticketCount--;System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticketCount + "张票");return false;}}
}

同步方法

同步静态(static)方法：就是把synchronized关键字加到静态方法上

格式：

修饰符 static synchronized 返回值类型方法名(方法参数) { }

同步静态方法的锁对象是什么呢?

类名.class

package com.itheima.day013_Teacher.demo02_MaiPiao;
/*这个类当成任务类*/
public class Piao implements Runnable {// 票的总数private  int p=100;@Overridepublic void run() {while (true){synchronized (this){if(p>0){// 卖票的行为System.out.println(Thread.currentThread().getName()+"卖了:"+p-- +"号票");}else {System.out.println(Thread.currentThread().getName()+"卖票结束...");break;}}}}/*@Overridepublic void run() {while (true){// 人为规定,返回true表示可以继续卖票,返回false,表示票卖完了boolean r =  maiPiao();if(!r){break;}}}*/private synchronized boolean maiPiao() {if(p>0){// 卖票的行为System.out.println(Thread.currentThread().getName()+"卖了:"+p-- +"号票------------");return true;}else {System.out.println(Thread.currentThread().getName()+"卖票结束...");return false;}}
}

Lock锁

虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock

Lock实现提供比使用synchronized方法和语句可以获得更广泛的锁定操作

Lock中提供了获得锁和释放锁的方法

void lock()：获得锁

void unlock()：释放锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

ReentrantLock的构造方法

ReentrantLock()：创建一个ReentrantLock的实例

package com.itheima.threaddemo012;import java.util.concurrent.locks.ReentrantLock;public class Ticket implements Runnable {//票的数量private int ticket = 100;private Object obj = new Object();private ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while (true) {//synchronized (obj){//多个线程必须使用同一把锁.try {lock.lock();//获得锁if (ticket <= 0) {//卖完了break;} else {Thread.sleep(100);ticket--;System.out.println(Thread.currentThread().getName() + "在卖票,还剩下" + ticket + "张票");}} catch (InterruptedException e) {e.printStackTrace();} finally {lock.unlock();//释放锁}// }}}
}

死锁

线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行。

生产者消费者

生产者消费者模式概述

生产者消费者理想情况

生产者等待

package com.itheima.day013_Teacher.demo04_tongXin;
/*桌子类,会包含我们的共享数据*/
public class ZhuoZi {private String bz;// 包子是否存在private int count;// 表示已经吃了多少个包子// 生成包子的方法public void shengChan(){synchronized (this){if(count==9){System.out.println("生产够了...");Thread.currentThread().stop();}if(bz!=null){// 有包子,等待try {this.wait();// 将来被别的线程叫醒之后,代码会从这里继续往下走!} catch (InterruptedException e) {e.printStackTrace();}}// 做包子bz = "猪肉馅的包子";System.out.println("厨师做了一个:"+bz);this.notifyAll();// 叫醒对方}}// 吃包子的方法public void chiBaoZi(){synchronized (this){if(count>=10){System.out.println("吃饱了...");Thread.currentThread().stop();///System.exit(0);}if(bz ==null){// 说明没有包子,等一会try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}// 代码走到这里的时候,说明一定是有包子,开吃count++;System.out.println("吃货吃了:"+bz+",当前是第"+count+"个包子");bz=null;this.notifyAll();}}
}

package com.itheima.day013_Teacher.demo04_tongXin;public class ChiHuo implements Runnable{// 通过构造方法传递想要使用的数据public ChiHuo(ZhuoZi z) {this.z = z;}private ZhuoZi z ;

package com.itheima.day013_Teacher.demo04_tongXin;public class ChuShi implements Runnable{private ZhuoZi z;public ChuShi(ZhuoZi z) {this.z = z;}@Overridepublic void run() {while (true){z.shengChan();}}
}

package com.itheima.day013_Teacher.demo04_tongXin;public class Entry {public static void main(String[] args) {ZhuoZi z = new ZhuoZi();ChiHuo ch = new ChiHuo(z);ChuShi cs = new ChuShi(z);//创建线程,给厨师和吃货绑定任务new Thread(ch).start();new Thread(cs).start();}
}

厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第1个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第2个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第3个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第4个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第5个包子
厨师做了一个:猪肉馅的包子
吃货吃了:猪肉馅的包子,当前是第6个包子
厨师做了一个:猪肉馅的包子
吃

等待和唤醒的方法

为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中 Object类的等待和唤醒方法：

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

阻塞队列实现等待唤醒机制

阻塞队列继承结构

阻塞队列实现等待唤醒机制

BlockingQueue的核心方法：

put(anObject):将参数放入队列，如果放不进去会阻塞。
take():取出第一个数据，取不到会阻塞。

常见BlockingQueue：

ArrayBlockingQueue：底层是数组，有界。

LinkedBlockingQueue：底层是链表，无界。但不是真正的无界，最大为int的最大值。

多线程,了解-概念-实现方式-常见方法-安全问题-死锁-生产者消费者相关推荐

Java多线程学习三：有哪几种实现生产者消费者模式的方法
我们先来看看什么是生产者消费者模式,生产者消费者模式是程序设计中非常常见的一种设计模式,被广泛运用在解耦.消息队列等场景.在现实世界中,我们把生产商品的一方称为生产者,把消费商品的一方称为消费者,有时 ...
Linux多线程实践(5) --Posix信号量与互斥量解决生产者消费者问题
Posix信号量 Posix 信号量有名信号量无名信号量 sem_open sem_init sem_close sem_destroy sem_unlink sem_wait sem_post ...
Java 多线程（二）线程间的通信应用--生产者消费者（未完）
对于多个生产者和消费者. 为什么要定义while判断标记. 原因:让被唤醒的线程再一次判断标记. 为什么定义notifyAll, 因为需要唤醒对方线程. 因为只用notify,容易出现只唤醒本方线程的 ...
爬虫--05：多线程与生产者消费者模型
Crawler - 05: Multithreading- und Produzenten-Verbrauchermodell 多线程一.多线程的基本介绍 1.介绍 2.程序中模拟多任务二.创建多 ...
生产者/消费者问题的多种Java实现方式
实质上,很多后台服务程序并发控制的基本原理都可以归纳为生产者/消费者模式, 生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以 ...
生产者/消费者问题的多种Java实现方式--转
实质上,很多后台服务程序并发控制的基本原理都可以归纳为生产者/消费者模式,而这是恰恰是在本科操作系统课堂上老师反复讲解,而我们却视而不见不以为然的.在博文<一种面向作业流(工作流)的轻量级可复用 ...
多线程生产者消费者模型
1. 基础知识: 1. 什么是生产者-消费者模式: 比如有两个进程A和B,它们共享一个固定大小的缓冲区,A进程产生数据放入缓冲区,B进程从缓冲区中取出数据进行计算,那么这里其实就是一个生产者和消费者的 ...
Java 5种方法实现生产者消费者问题与2种方法实现读者写者问题
摘要: Java实现生产者消费者问题与读者写者问题 1.生产者消费者问题生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从 ...
多线程设计模式:生产者-消费者
一.两个线程一个生产者一个消费者需求情景 – 两个线程,一个负责生产,一个负责消费,生产者生产一个,消费者消费一个. 涉及问题同步问题:如何保证同一资源被多个线程并发访问时的完整性.常用的同步方法 ...

多线程,了解-概念-实现方式-常见方法-安全问题-死锁-生产者消费者

了解

简单了解多线程

简单了解多线程

简单了解多线程

简单了解多线程

简单了解多线程

概念

线程相关的概念

并发和并行

并发和并行

并发和并行

并发和并行

进程和线程

进程：是正在运行的软件

进程和线程

进程和线程

线程：是进程中的单个顺序控制流，是一条执行路径。

小结

实现方式

多线程的实现方式

多线程的实现方案

两个小问题：

多线程的实现方式

三种方式的对比

常见方法

线程类的常见方法

获取和设置线程名称

获得当前线程的对象

线程休眠

线程调度

CPU

线程的优先级

后台线程/守护线程

线程生命周期

安全问题

线程的安全问题

卖票案例的思考

卖票案例数据安全问题的解决

同步代码块

同步方法

同步方法

Lock锁

死锁

死锁

生产者消费者

生产者消费者模式概述

生产者消费者理想情况

生产者等待

等待和唤醒的方法

阻塞队列实现等待唤醒机制

阻塞队列继承结构

阻塞队列实现等待唤醒机制

多线程,了解-概念-实现方式-常见方法-安全问题-死锁-生产者消费者相关推荐

最新文章

热门文章