带你了解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高级编程----多线程部分的讲解，如有错误，欢迎指正。

如果对你有帮助，欢迎关注点赞加收藏哦!!!。