带你了解Java高级编程-----多线程
对于Java的学习,基本的步骤是Java基础编程,掌握了Java语言的基本语法、数组、面向对象编程、异常处理这四部分之后,就要开始对Java高级编程进一步学习
tips:Java高级编程,是以Java基础编程为基础,是进一步的延申。
这篇文章主要是针对Java高级编程中的----多线程。
文章目录
带你了解Java高级编程-----多线程多线程一、简单了解什么是多线程?二、线程相关的基本概念1.程序(program)2.进程(process)3.线程(thread)4.CPU(并行与并发) 三、线程的创建和使用1.线程的创建(1)继承Thread类的方式:(2)实现Runnable接口的方式:(3)实现Callable接口,Future的方式:(4) 使用线程池 2.Thread类的相关的方法3.线程的调度4.线程的优先级5.线程的分类 三、线程的生命周期四、线程的同步1.窗口售票:2.同步机制:3.锁4.Lock锁 五、线程的通信六、关于线程通讯的经典例题多线程
Java 给多线程编程提供了内置的支持。 一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条线程并行执行不同的任务。
提示:以下是本篇文章正文内容,下面案例可供参考
一、简单了解什么是多线程?
多线程是多任务的一种特别的形式,但多线程使用了更小的资源开销。
有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如:程序中有两个子系统需要并发执行,这时候就需要利用多线程编程。通过对多线程的使用,可以编写出非常高效的程序。不过请注意,如果你创建太多的线程,程序执行的效率实际上是降低了,而不是提升了。请记住,上下文的切换开销也很重要,如果你创建了太多的线程,CPU 花费在上下文的切换的时间将多于执行程序的时间!
多线程程序的优点:
提高应用程序的响应。对图形化界面更有意义,可增强用户体验。提高计算机系统CPU的利用率。改善程序结构。将既长又复杂的进程分为多个线程,独立运行,利于理解和修改。
使用多线程的情况:
1.程序需要同时执行两个或多个任务。
2.程序需要实现一些需要等待的任务时,如用户输入、文件读写操作、网络操作、搜索等。
3.需要一些后台运行的程序时。
二、线程相关的基本概念
1.程序(program)
程序是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码,静态对象
2.进程(process)
进程是程序的一次执行过程,或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。——生命周期
如:运行中的QQ,运行中的MP3播放器程序是静态的,进程是动态的进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域。
【我们可以在任务管理器中查看自己电脑点相关进程。】
3.线程(thread)
进程可进一步细化为线程,是一个程序内部的一条执行路径。
①若一个进程同一时间并行执行多个线程,就是支持多线程的。
②线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
③一个进程中的多个线程共享相同的内存单元/内存地址空间它们从同一堆中分配对象,可以访问相同的变量和对象。
这就使得线程间通信更简便、高效。但多个线程操作共享的系统源可能就会带来安全的隐患。
4.CPU(并行与并发)
(1)单核、多核CPU理解:
①单核CPU,其实是一种假的多线程,因为在一个时间单元内,也只能执行一个线程的任务。
②多核CPU的话,才能更好的发挥多线程的效率。(现在的服务器都是多核的)
(2)并行、并发:
①并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
②并发:一个CPU(采用时间片)同时执行多个任务。比如:多个人做同一件事。
三、线程的创建和使用
1.线程的创建
创建新执行线程有四种方法:
(1)继承Thread类的方式;
(2)实现Runnable接口的方式;
(3)实现Callable接口,Future的方式;
(4)线程池;
(1)继承Thread类的方式:
Thread类的特性
①每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体。
②通过该Thread对象的start()方法来启动这个线程,而非直接调用run()。
/*** 多线程的创建 :*方式一:继承thread类* 1.创建一个继承于Thread类的子类* 2.重写thread类的run()----> 将此线程执行的操作声明放在run()中* 3.创建按thread类的子类的对象* 4.通过此对象调用start()*///1.创建继承thread的类class MyThread extends Thread {//2.重写run()方法public void run() {for (int i = 0; i < 100; i++) {if (i % 2 == 0) {System.out.println(i);}}}}public class ThreadTest {public static void main(String[] args) {//3.创建thread类的子类对象MyThread t1 = new MyThread();//4.通过此对象调用start()t1.start();/** 在主线程中运行顺序不确定*/for (int i=0; i< 100; i++){if(i % 2 == 0){System.out.println("-------------------");}}}}
上述代码的运行结果“------------------” 和 偶数 混合出现【在主线程的运行顺序是不确定的】
(2)实现Runnable接口的方式:
/*** 创建多线程的方式二:实现Runnable接口* 1.创建一个实现了Runnable接口的类* 2.实现类去实现Runnable中的抽象方法:run()* 3.创建一个实现类的对象* 4.将此对象最为参数传递到Thread类的构造器中,创建Thread类的对象* 5.通过Thread类的对象调用Start()*///1.创建一个实现Runnable接口的类class MThread implements Runnable{//实现Runnable中的抽象方法:run()@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 == 0){System.out.println(Thread.currentThread().getName() + " : " + i);}}}}public class ThreadTest1 {public static void main(String[] args) {//3.创建一个实现类的对象MThread mThread = new MThread();//4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象Thread t1 = new Thread(mThread);t1.setName("线程一");//5.通过Thread类的对象调用start() ①启动线程 ②调用当前线程的run() -->调用了Runnable类型的targett1.start();//创建另一个线程Thread t2 = new Thread(mThread);t2.setName("线程二");t2.start();}}
简而言之,在实现Runnable的接口后,需要借用Thread的构造器进行创建Thread类。
前两种方式的比较:
①这两种创建线程的方式实际上都是利用了Thread类。【同】
②线程要实现的方法都要重写run()方法,通过run()方法实现。【同】
③继承Thread:线程代码存放Thread子类run方法中。【异】
④实现Runnable:线程代码存在接口的子类的run方法。【异】
⑤实现Runnable类的优势:避免了单继承的局限性;多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。
【总结】:我们弄懂了接口和继承,就不难理解Thread和Runnable。
在刚接触的时候可能会有些迷糊这二者的区别于联系,但是实践和总结过后我们会发现这是两个完全不同的实现多线程,
一是多个线程分别完成自己的任务,一个是多个线程共同完成一个任务。
其实,在实现一个任务用多个线程来做也可以用继承Thread类来实现,只是比较麻烦,一般我们用实现Runnable接口来实现。
(3)实现Callable接口,Future的方式:
import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;/*** 创建线程的方式三 : 实现Callable接口。 -----JDK 5.0新增** 如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?* 1.call()可以有返回值的。* 2.call()可以抛出异常* 3.Callable 是支持泛型的*///1.创建一个实现Callable的实现类class NumThread implements Callable<Integer>{//2.实现call方法,将此线程需要执行的操作声明在call()中@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i <= 100; i++) {if (i % 2 == 0){System.out.println(i);sum += i;}}return sum;}}public class ThreadNew {public static void main(String[] args) {//3.创建Callable接口实现类的对象NumThread numThread = new NumThread();//4.将此Callable接口实现类的对象作为传递到FutureTask构造器中,创建FutureTask的对象FutureTask<Integer> futureTask = new FutureTask<Integer>(numThread);//5.将FutureTask的对象作为参数传递到Thread类的构造中,创建Thread对象,并调用start()new Thread(futureTask).start();try {//6.获取Callable中call方法的返回值//get() 返回值即为FutureTask构造器参数Callable实现类重写的coll()的返回值Integer o = futureTask.get();System.out.println("总和为 : " + o);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}}
与使用Runnable相比, Callable功能更强大些。
①可以有返回值;【call()方法】
②能够抛出异常;【call()方法】
③能够支持泛型
(4) 使用线程池
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.ThreadPoolExecutor;/**** 好处 :* 提高响应速度(减少了创建新线程的时间);* 降低资源消耗(重复利用线程池中线程,不需要每次都创建);* 便于线程管理;* corePoolSize:核心池的大小* maximumPoolSize:最大线程数* keepAliveTime:线程没有任务时最多保持多长时间后会终止**/class NumberThread implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 == 0){System.out.println(Thread.currentThread().getName() + ":" + i);}}}}class NumberThread1 implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 != 0){System.out.println(Thread.currentThread().getName() + ":" + i);}}}}public class ThreadPool {public static void main(String[] args) {//1.提供指定线程数量的线程池(此处指定了10个)ExecutorService executorService = Executors.newFixedThreadPool(10);ThreadPoolExecutor executor = (ThreadPoolExecutor) executorService;//设置线程池的属性System.out.println(executorService.getClass());//2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象executorService.execute(new NumberThread()); //适合适用于RunnableexecutorService.execute(new NumberThread1()); //适合适用于Runnable//executorService.submit( Callable callable); //适合使用于Callable//3.关闭连接池executorService.shutdown();}}
2.Thread类的相关的方法
下表列出了Thread类的一些重要方法:
测试线程是否处于活动状态。 上述方法是被Thread对象调用的。下面的方法是Thread类的静态方法:
还有两个不推荐使用的方法:
3.线程的调度
计算机通常只有一个CPU,在任意时刻只能执行一条机器指令,每个线程只有获得CPU的使用权才能执行指令。所谓多线程的并发运行,其实是指从宏观上看,各个线程轮流获得CPU的使用权,分别执行各自的任务。在运行池中,会有多个处于就绪状态的线程在等待CPU,JAVA虚拟机的一项任务就是负责线程的调度,线程调度是指按照特定机制为多个线程分配CPU的使用权。
有两种调度模型:分时调度模型和抢占式调度模型。
4.线程的优先级
每一个 Java 线程都有一个优先级,这样有助于操作系统确定线程的调度顺序。
Java 线程的优先级是一个整数,其取值范围是1 (Thread.MIN_PRIORITY ) - 10(Thread.MAX_PRIORITY );默认情况下,每一个线程都会分配一个优先级 NORM_PRIORITY(5)。
具有较高优先级的线程对程序更重要,并且应该在低优先级的线程之前分配处理器资源。但是,线程优先级不能保证线程执行的顺序,而且非常依赖于平台。
/*** 【线程的优先级】:(线程优先级是一个概率事件)* 1.* MAX_PRIORITY : 10* MIN_PRIORITY : 1* NORM_PRIORITY : 5 -->默认的线程优先级* 2.如何获取和设置当前线程的优先级:* getPriority() : 获取线程的优先级* setPriority(int p) : 设置线程的优先级** 【说明:高优先级的线程要抢占低优先级线程cpu的执行权,但只是从概率上讲,高优先级的线程高概率的情况下被执行*并不意味着只有当高优先级的线程执行完以后,低优先级的线程才执行】*/class ThreadPriority extends Thread{@Overridepublic void run() {for (int i = 0; i< 100; i++){if (i % 2 != 0){System.out.println(Thread.currentThread().getName() + ">>" + Thread.currentThread().getPriority() + " : " + i);}}}}public class ThreadPriorityTest {public static void main(String[] args) {ThreadPriority p1 = new ThreadPriority();//设置分线程的优先级p1.setPriority(Thread.MAX_PRIORITY);p1.setName("高优先级");p1.start();//给主线程命名Thread.currentThread().setName("低优先级");Thread.currentThread().setPriority(Thread.MIN_PRIORITY);for (int i = 0; i< 100; i++) {if (i % 2 == 0) {System.out.println(Thread.currentThread().getName() + ">>" + Thread.currentThread().getPriority() + " : " + i);}}}}
【说明】:优先级的高低确定了线程抢夺cpu的执行权,但优先级归根结底是一个概率事件,只能说高优先级的更容易被cup先执行。
5.线程的分类
Java中的线程分为两类:
一种是守护线程,一种是用户线程。
它们在几乎每个方面都是相同的,唯一的区别是判断JVM何时离开。守护线程是用来服务用户线程的,通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。Java垃圾回收就是一个典型的守护线程。若JVM中都是守护线程,当前JVM将退出。形象理解:兔死狗烹,鸟尽弓藏(比喻事情成功后,把出过力的人抛弃或杀死。)
三、线程的生命周期
线程是一个动态执行的过程,它也有一个从产生到死亡的过程。
新建:使用 new 关键字和 Thread 类或其子类建立一个线程对象后,该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪:当线程对象调用了start()方法之后,该线程就进入就绪状态。就绪状态的线程处于就绪队列中,要等待JVM里线程调度器的调度。
运行:如果就绪状态的线程获取 CPU 资源,就可以执行 run(),此时线程便处于运行状态。处于运行状态的线程最为复杂,它可以变为阻塞状态、就绪状态和死亡状态。
阻塞:如果一个线程执行了sleep(睡眠)、suspend(挂起)等方法,失去所占用资源之后,该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种:
(1)等待阻塞:运行状态中的线程执行 wait() 方法,使线程进入到等待阻塞状态。
(2)同步阻塞:线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
(3)其他阻塞:通过调用线程的 sleep() 或 join() 发出了 I/O 请求时,线程就会进入到阻塞状态。当 sleep() 状态超时,join() 等待线程终止或超时,或者 I/O 处理完毕,线程重新转入就绪状态。
死亡:一个运行状态的线程完成任务或者其他终止条件发生时,该线程就切换到终止状态。
四、线程的同步
1.窗口售票:
在说明线程的同步问题前,大家先看一下经典的例题:模拟火车站售票程序,开启三个窗口售票。
/***模拟火车站售票程序,开启三个窗口售票** @Author duokanzhouzhou* @Create /7/17*/public class WindowTestO {public static void main(String[] args) {Windows w1 = new Windows();Windows w2 = new Windows();Windows w3 = new Windows();w1.setName("窗口一");w2.setName("窗口二");w3.setName("窗口三");w1.start();w2.start();w3.start();}}class Windows extends Thread{private static int ticket = 100;@Overridepublic void run() {while(true){if (ticket > 0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() + "卖票,窗口为:----> " + ticket);ticket--;}else {break;}}}}
按照上面通过继承Thread类来实现的解决方案,在运行出来的结果是三个窗口都卖出了100张票,而且代码中的Thread.sleep(100);在运行中并没有体现出来。
但实际,应该是一共一百张票,三个窗口不能够拥有重复。
多线程出现了安全问题
问题的原因:
当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行。导致共享数据的错误。
解决办法:
对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
为了解决以上代码存在的不足,我们引入线程同步机制Java对于多线程的安全问题提供了专业的解决方式:同步机制
2.同步机制:
Synchronized的使用:
同步代码块:
synchronized (对象){
// 需要被同步的代码;
}
synchronized还可以放在方法声明中,表示整个方法为同步方法。 例如: public synchronized void show (String name){ …. }
我们做如下优化:
/*** 使用同步代码块解决继承Thread类的方式的线程安全问题*** 说明 : 在继承Thread类创建多线程的方式中,慎用this同步监视器**/public class WindowTest {public static void main(String[] args) {Window w1 = new Window();Window w2 = new Window();Window w3 = new Window();w1.setName("窗口一");w2.setName("窗口二");w3.setName("窗口三");w1.start();w2.start();w3.start();}}class Window extends Thread{private static int ticket = 100;//private static Object obj = new Object(); //方法一1.1@Overridepublic void run() {while (true){//synchronized (obj){ //方法1.2//简单方式,类也是对象【Window.class运行过程中只运行了一次】 //方法2synchronized (Window.class){//错误方式 : synchronized(this),this 代表着w1,w2,w3if (ticket > 0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(getName() + ":买票,票号为 --》" + ticket);ticket--;}else {break;}}}}}
使用synchronized时,要格外注意同步监视器的使用。
使用synchronized时,要格外被同步的代码的范围。
在继承Thread类创建多线程的方式中,慎用this同步监视器。
下面是实现Runnable接口的synchronized的使用
public class WindowTest2{public static void main(String[] args) {Window2 w2 = new Window2();Thread t1 = new Thread(w2);Thread t2 = new Thread(w2);Thread t3 = new Thread(w2);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}class Window2 implements Runnable{private int ticket = 100;//Object obj = new Object();@Overridepublic void run() {while(true) {//synchronized(obj)//最近但的同步监视器,this,当前对象synchronized (this) {if (ticket > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 卖票,票号为 : " + ticket);ticket--;} else {break;}}}}}
在实现Runnable接口的方式下,可以使用this同步监视器
下面是使用同步方法,以实现Runnable接口来举例,继承Thread的方式与之相同就不多加赘述。
class Window3 implements Runnable{private int ticket = 100;@Overridepublic void run() {while(true){show();}}//同步方法private synchronized void show(){//synchronized (this) {if (ticket > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " 买票,票号为 : " + ticket);ticket--;}//}}}public class WindowTest3 {public static void main(String[] args) {Window3 w3 = new Window3();Thread t1 = new Thread(w3);Thread t2 = new Thread(w3);Thread t3 = new Thread(w3);t1.setName("窗口1");t2.setName("窗口2");t3.setName("窗口3");t1.start();t2.start();t3.start();}}
3.锁
(1). 释放锁的操作
当前线程的同步方法、同步代码块执行结束。当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、
该方法的继续执行。当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导
致异常结束。当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线
程暂停,并释放锁。
(2). 不释放锁的操作
线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁(同步监视器)。
*>应尽量避免使用suspend()和resume()来控制线程。
(3).死锁
不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁;出现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于
阻塞状态,无法继续解决方法
①专门的算法、原则
②尽量减少同步资源的定义
③尽量避免嵌套同步
4.Lock锁
ReentrantLock 类实现了 Lock ,它拥有与 synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock,可以显式加锁、释放锁。
Lock(锁)class A{
private final ReentrantLock lock = new ReenTrantLock();
public void m(){
lock.lock();
try{
//保证线程安全的代码; }
finally{
lock.unlock();
} } }
注意:如果同步代码有异常,要将unlock()写入finally语句块
public class LockTest {public static void main(String[] args) {Window2 window2 = new Window2();Thread thread1 = new Thread(window2);Thread thread2 = new Thread(window2);Thread thread3 = new Thread(window2);thread1.setName("窗口1");thread2.setName("窗口2");thread3.setName("窗口3");thread1.start();thread2.start();thread3.start();}}class Window2 implements Runnable{private int ticket = 100;//1.实例化ReentrantLockprivate ReentrantLock lock = new ReentrantLock(true);//写入true则为公平(先进先出原则);写入false则为不公平()@Overridepublic void run() {while (true) {try {//2.调用lock()【上锁】lock.lock();if (ticket > 0) {try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " : " + "售票,票号为-->" + ticket);ticket--;}else {break;}} finally {//3.调用unlock()【解锁】lock.unlock();}}}}
【说明】:
方式一:同步代码块
1.操作共享数据代码,即需要被同步的代码 ---->不能多或少包含代码
2.共享数据:多个线程共同操作的数据 3.同步监视器,俗称:‘锁’,任何一个类的对象,都可以充当锁。(多线程必须同用一把锁)】 (补充 : 在世先Runnable接口创建多线程的方式中,可以考虑使用this充当同步监视器)
方式二:同步方法
如果操作共享数据的代码完整的声明在一个方法中,不妨将此方法声明同步:
解决看线程的安全问题 ----好处
操作同步代码时,只能有一个线程参与,其他线程等待。相当于是一个单线程的过程,效率低。 —坏处
方式三:Lock锁
Lock需要手动的启动同步(Lock()),同时结束同步也需要手动的实现(unlock())
Lock —> 同步代码块(已经进入了方法体,分配了相应资源) —> 同步方法(在方法体之外)
五、线程的通信
我们经常说线程之间的通信,线程之间的协作,但是根据他的应用场景其实是很容易搞清楚的;
比如说:从日常生活的角度来说:生产者-消费者,又比如说队列,等等的Demo,
去超市购物,你是消费者,你没有钱,就要等有钱才能买;超市没有货物,那你就等超市有货物再买。
这种相互等待的过程,就是线程之间通信的过程,也就是协作的过程,那么从以下两个角度或者更多的角度去解决这个问题,并且说明一些关键字的介绍。
我们可以通过实例来进一步了解:
使用两个线程打印 1-100。线程1, 线程2 交替打印
/*** 涉及到的三个方法:* wait() : 一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器* notify() : 一旦执行此方法,就会唤醒被wait的一个线程。如果有多个线程被wait,就唤醒优先级最高的那个* notifyAll() : 一旦执行此方法,就会唤醒所有被wait的一个线程** 说明:* 1.wait() notify() notifyAll() 三个方法必须使用在同步代码块 或 同步方法中。* 2.wait() notify() notifyAll() 三个方法必须是同步代码块 或 同步方法中的同步监视器。*否则,会出现IllegalMonitorStateException异常* 3.wait() notify() notifyAll() 三个方法是定义在java.lang.Object类中。**/class Number implements Runnable{private int number = 1;@Overridepublic void run() {while (true){synchronized (this) {this.notify();//唤醒notify() 与 wait()一起使用try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}if (number <= 100){System.out.println(Thread.currentThread().getName() + " : " + number);number++;//是的调用如下wait()方法的线程进入阻塞状态try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}else {break;}}}}}public class CommunicationTest {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();}}
sleep() 和 wait()的异同?
1.相同点:一旦执行方法,都可以是当前的线程进入阻塞状态
2.不同点:
两个方法声明的位置不同:Thread类中声明sleep(),Object类中声明wait()调用的要求不同:sleep()可以在任何需要的场景下调用。wait() 必须使用在同步代码块或同步方法中关于是否释放同步监视器:sleep()不会释放锁,wait()会释放锁
上图的代码中,同步监视器为this,所以wait() 和 notify()也使用this,【书写是可省略】// 若不是this,则进行书写时不能省略。
六、关于线程通讯的经典例题
生产者/消费者问题:
生产者(Productor)将产品交给店员(Clerk),而消费者(Customer)从店员处取走产品,店员一次只能持有固定数量的产品(比如:20),如果生产者试图生产更多的产品,店员会叫生产者停一下,如果店中有空位放产品了再通知生产者继续生产;如果店中没有产品了,店员会告诉消费者等一下,如果店中有产品了再通知消费者来取走产品。
这里可能出现两个问题:
生产者比消费者快时,消费者会漏掉一些数据没有取到。
消费者比生产者快时,消费者会取相同的数据。
编写生产者消费者多线程程序,设有一个最大库存量为4的电视机仓库,生产10台电视机,一边生产一边销售(消费)。
以上内容便是对Java高级编程----多线程部分的讲解,如有错误,欢迎指正。
如果对你有帮助,欢迎关注点赞加收藏哦!!!。