Java多线程

已于 2024-06-12 11:23:27 修改
阅读量1.2k 收藏 12
点赞数 3
分类专栏： 多线程与高并发 文章标签： 1024程序员节 多线程 java
于 2020-10-24 19:50:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bookssea/article/details/109264549
版权

1.1 多线程介绍
学习多线程之前，我们先要了解几个关于多线程有关的概念。

进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

image.png

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程

image.png

什么是多线程呢？即就是一个程序中有多个线程在同时执行。

通过下图来区别单线程程序与多线程程序的不同：

l 单线程程序：即，若有多个任务只能依次执行。当上一个任务执行结束后，下一个任务开始执行。如，去网吧上网，网吧只能让一个人上网，当这个人下机后，下一个人才能上网。

l 多线程程序：即，若有多个任务可以同时执行。如，去网吧上网，网吧能够让多个人同时上网。

image.png

1.2 程序运行原理
分时调度
所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。

抢占式调度
优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

image.png

1.2.1 抢占式调度详解
大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。

image.png

实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。

其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

1.3 主线程
回想我们以前学习中写过的代码，当我们在dos命令行中输入java空格类名回车后，启动JVM，并且加载对应的class文件。虚拟机并会从main方法开始执行我们的程序代码，一直把main方法的代码执行结束。如果在执行过程遇到循环时间比较长的代码，那么在循环之后的其他代码是不会被马上执行的。如下代码演示：

class Demo{

String name;

Demo(String name){

   this.name = name;

}

void show() {

   for (int i=1;i<=10000 ;i++ ) {

        System.out.println("name="+name+",i="+i);

    }

}
}

 

class ThreadDemo {

public static void main(String[] args) {

         Demo d = new Demo("小强");

         Demo d2 = new Demo("旺财");

         d.show();

         d2.show();

         System.out.println("Hello World!");

}

}

若在上述代码中show方法中的循环执行次数很多，这时在d.show();下面的代码是不会马上执行的，并且在dos窗口会看到不停的输出name=小强,i=值，这样的语句。为什么会这样呢？

原因是：jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。当程序的主线程执行时，如果遇到了循环而导致程序在指定位置停留时间过长，则无法马上执行下面的程序，需要等待循环结束后能够执行。

那么，能否实现一个主线程负责执行其中一个循环，再由另一个线程负责其他代码的执行，最终实现多部分代码同时执行的效果？

能够实现同时执行，通过Java中的多线程技术来解决该问题。

1.4 Thread类
该如何创建线程呢？通过API中搜索，查到Thread类。通过阅读Thread类中的描述。Thread是程序中的执行线程。Java 虚拟机允许应用程序并发地运行多个执行线程。

构造方法

image.png

常用方法

image.png

继续阅读，发现创建新执行线程有两种方法。

一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。

另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

1.5 创建线程方式一继承Thread类
创建线程的步骤：

1 定义一个类继承Thread。

2 重写run方法。

3 创建子类对象，就是创建线程对象。

4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。

测试类
public class Demo01 {

public static void main(String[] args) {

//创建自定义线程对象

MyThread mt = new MyThread("新的线程！");

//开启新线程

mt.start();

//在主方法中执行for循环

for (int i = 0; i < 10; i++) {

System.out.println("main线程！"+i);

}

}

}

自定义线程类
public class MyThread extends Thread {

//定义指定线程名称的构造方法

public MyThread(String name) {

//调用父类的String参数的构造方法，指定线程的名称

super(name);

}

/**

 * 重写run方法，完成该线程执行的逻辑

 */

@Override

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(getName()+"：正在执行！"+i);

}

}

}

思考：线程对象调用 run方法和调用start方法区别？

线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。

1.5.1 继承Thread类原理
我们为什么要继承Thread类，并调用其的start方法才能开启线程呢？

继承Thread类：因为Thread类用来描述线程，具备线程应该有功能。那为什么不直接创建Thread类的对象呢？如下代码：

Thread t1 = new Thread();

t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。
创建线程的目的是什么？

是为了建立程序单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定线程要执行的任务。

对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。

Thread类run方法中的任务并不是我们所需要的，只有重写这个run方法。既然Thread类已经定义了线程任务的编写位置（run方法），那么只要在编写位置（run方法）中定义任务代码即可。所以进行了重写run方法动作。

1.5.2 多线程的内存图解
多线程执行时，到底在内存中是如何运行的呢？

以上个程序为例，进行图解说明：

多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。

image.png

当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。

1.5.3 获取线程名称
开启的线程都会有自己的独立运行栈内存，那么这些运行的线程的名字是什么呢？该如何获取呢？既然是线程的名字，按照面向对象的特点，是哪个对象的属性和谁的功能，那么我们就去找那个对象就可以了。查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象。还有个方法是获取当前线程对象的名称。既然找到了，我们就可以试试。

image.png

Thread.currentThread()获取当前线程对象

Thread.currentThread().getName();获取当前线程对象的名称

class MyThread extends Thread {  //继承Thread

MyThread(String name){

super(name);

}

//复写其中的run方法

public void run(){

for (int i=1;i<=20 ;i++ ){

System.out.println(Thread.currentThread().getName()+",i="+i);

}

}

}

class ThreadDemo {

public static void main(String[] args) {

//创建两个线程任务

MyThread d = new MyThread();

MyThread d2 = new MyThread();

d.run();//没有开启新线程, 在主线程调用run方法

d2.start();//开启一个新线程，新线程调用run方法

}

}

通过结果观察，原来主线程的名称：main；自定义的线程：Thread-0，线程多个时，数字顺延。如Thread-1…

进行多线程编程时，不要忘记了Java程序运行是从主线程开始，main方法就是主线程的线程执行内容。

1.6 创建线程方式—实现Runnable接口
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程。

为何要实现Runnable接口，Runable是啥玩意呢？继续API搜索。

查看Runnable接口说明文档：Runnable接口用来指定每个线程要执行的任务。包含了一个 run 的无参数抽象方法，需要由接口实现类重写该方法。

接口中的方法

image.png

Thread类构造方法

image.png

创建线程的步骤。

1、定义类实现Runnable接口。

2、覆盖接口中的run方法。。

3、创建Thread类的对象

4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

5、调用Thread类的start方法开启线程。

代码演示：

public class Demo02 {

public static void main(String[] args) {

//创建线程执行目标类对象

Runnable runn = new MyRunnable();

//将Runnable接口的子类对象作为参数传递给Thread类的构造函数

Thread thread = new Thread(runn);

Thread thread2 = new Thread(runn);

//开启线程

thread.start();

thread2.start();

for (int i = 0; i < 10; i++) {

System.out.println("main线程：正在执行！"+i);

}

}

}
自定义线程执行任务类
public class MyRunnable implements Runnable{

 

//定义线程要执行的run方法逻辑

@Override

public void run() {

 

for (int i = 0; i < 10; i++) {

System.out.println("我的线程：正在执行！"+i);

}

}

}

1.6.1 实现Runnable的原理
为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？

实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。

创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。

1.6.2 实现Runnable的好处
第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

1.7 线程的匿名内部类使用
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

方式1：创建线程对象时，直接重写Thread类中的run方法
new Thread() {

public void run() {

for (int x = 0; x < 40; x++) {

System.out.println(Thread.currentThread().getName()

  • “…X…” + x);

}

}

}.start();
方式2：使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法
Runnable r = new Runnable() {

public void run() {

for (int x = 0; x < 40; x++) {

System.out.println(Thread.currentThread().getName()

  • “…Y…” + x);

}

}

};

new Thread®.start();
2.1 线程池概念
线程池，其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

image.png

我们详细的解释一下为什么要使用线程池？

在java中，如果每个请求到达就创建一个新线程，开销是相当大的。在实际使用中，创建和销毁线程花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务。

线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重复使用线程，线程创建的开销就被分摊到了多个任务上了，而且由于在请求到达时线程已经存在，所以消除了线程创建所带来的延迟。这样，就可以立即为请求服务，使用应用程序响应更快。另外，通过适当的调整线程中的线程数目可以防止出现资源不足的情况。

2.2 使用线程池方式–Runnable接口
通常，线程池都是通过线程池工厂创建，再调用线程池中的方法获取线程，再通过线程去执行任务方法。

Executors：线程池创建工厂类

public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对象

ExecutorService：线程池类

Future<?> submit(Runnable task)：获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤：

  1. 创建线程池对象

  2. 创建Runnable接口子类对象

  3. 提交Runnable接口子类对象

  4. 关闭线程池

代码演示：

public class ThreadPoolDemo {

public static void main(String[] args) {

//创建线程池对象

ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

//创建Runnable实例对象

MyRunnable r = new MyRunnable();

 

//自己创建线程对象的方式

//Thread t = new Thread(r);

//t.start(); ---> 调用MyRunnable中的run()

 

//从线程池中获取线程对象,然后调用MyRunnable中的run()

service.submit(r);

//再获取个线程对象，调用MyRunnable中的run()

service.submit(r);

service.submit(r);


//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

 

//关闭线程池

//service.shutdown();

}

}

Runnable接口实现类

public class MyRunnable implements Runnable {

@Override

public void run() {

System.out.println("我要一个教练");

 

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println("教练来了： " +Thread.currentThread().getName());

System.out.println("教我游泳,交完后，教练回到了游泳池");

}

}

2.3 使用线程池方式—Callable接口
Callable接口：与Runnable接口功能相似，用来指定线程的任务。其中的call()方法，用来返回线程任务执行完毕后的结果，call方法可抛出异常。

ExecutorService：线程池类

Future submit(Callable task)：获取线程池中的某一个线程对象，并执行线程中的call()方法

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

使用线程池中线程对象的步骤：

  1. 创建线程池对象

  2. 创建Callable接口子类对象

  3. 提交Callable接口子类对象

  4. 关闭线程池

代码演示：

public class ThreadPoolDemo {

public static void main(String[] args) {

//创建线程池对象

ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象

//创建Callable对象

MyCallable c = new MyCallable();

 

//从线程池中获取线程对象,然后调用MyRunnable中的run()

service.submit(c);

 

//再获取个教练

service.submit(c);

service.submit(c);

//注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中

 

//关闭线程池

//service.shutdown();

}

}

Callable接口实现类,call方法可抛出异常、返回线程任务执行完毕后的结果

public class MyCallable implements Callable {

@Override

public Object call() throws Exception {

System.out.println("我要一个教练:call");

Thread.sleep(2000);

System.out.println("教练来了： " +Thread.currentThread().getName());

System.out.println("教我游泳,交完后,教练回到了游泳池");

return null;

}

}

2.4 线程池练习：返回两个数相加的结果
要求：通过线程池中的线程对象，使用Callable接口完成两个数求和操作

Future接口：用来记录线程任务执行完毕后产生的结果。线程池创建与使用

V get() 获取Future对象中封装的数据结果

代码演示：

public class ThreadPoolDemo {

public static void main(String[] args) throws InterruptedException, ExecutionException {

//创建线程池对象

ExecutorService threadPool = Executors.newFixedThreadPool(2);

 

//创建一个Callable接口子类对象

//MyCallable c = new MyCallable();

MyCallable c = new MyCallable(100, 200);

MyCallable c2 = new MyCallable(10, 20);

 

//获取线程池中的线程，调用Callable接口子类对象中的call()方法, 完成求和操作

//<Integer> Future<Integer> submit(Callable<Integer> task)

// Future 结果对象

Future<Integer> result = threadPool.submit(c);

//此 Future 的 get 方法所返回的结果类型

Integer sum = result.get();

System.out.println("sum=" + sum);

 

//再演示

result = threadPool.submit(c2);

sum = result.get();

System.out.println("sum=" + sum);

//关闭线程池(可以不关闭)

 

}

}

Callable接口实现类

public class MyCallable implements Callable<Integer> {

//成员变量

int x = 5;

int y = 3;

//构造方法

public MyCallable(){

}

public MyCallable(int x, int y){

this.x = x;

this.y = y;

}


 

@Override

public Integer call() throws Exception {

return x+y;

}

}

3.1 知识点总结
创建线程的方式

方式1，继承Thread线程类

步骤

1， 自定义类继承Thread类

2， 在自定义类中重写Thread类的run方法

3， 创建自定义类对象(线程对象)

4， 调用start方法，启动线程，通过JVM，调用线程中的run方法

方式2，实现Runnable接口

步骤

1， 创建线程任务类 实现Runnable接口

2， 在线程任务类中 重写接口中的run方法

3， 创建线程任务类对象

4， 创建线程对象，把线程任务类对象作为Thread类构造方法的参数使用

5， 调用start方法，启动线程，通过JVM，调用线程任务类中的run方法

4.1 线程安全
如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

我们通过一个案例，演示线程的安全问题：
电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “功夫熊猫3”，本次电影的座位共100个(本场电影只能卖100张票)。

我们来模拟电影院的售票窗口，实现多个窗口同时卖 “功夫熊猫3”这场电影票(多个窗口一起卖这100张票)

需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟

测试类

public class ThreadDemo {

public static void main(String[] args) {

//创建票对象

Ticket ticket = new Ticket();

 

//创建3个窗口

Thread t1  = new Thread(ticket, "窗口1");

Thread t2  = new Thread(ticket, "窗口2");

Thread t3  = new Thread(ticket, "窗口3");

 

t1.start();

t2.start();

t3.start();

}

}

模拟票

public class Ticket implements Runnable {

//共100票

int ticket = 100;

 

@Override

public void run() {

//模拟卖票

while(true){

if (ticket > 0) {

//模拟选坐的操作

try {

Thread.sleep(1);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);

}

}

}

}

image.png

运行结果发现：上面程序出现了问题

票出现了重复的票

错误的票 0、-1

其实，线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。

4.2 线程同步（线程安全处理Synchronized）
java中提供了线程同步机制，它能够解决上述的线程安全问题。

线程同步的方式有两种：

方式1：同步代码块

方式2：同步方法

4.2.1 同步代码块
同步代码块: 在代码块声明上 加上synchronized

synchronized (锁对象) {

可能会产生线程安全问题的代码

}
同步代码块中的锁对象可以是任意的对象；但多个线程时，要使用同一个锁对象才能够保证线程安全。

使用同步代码块，对电影院卖票案例中Ticket类进行如下代码修改：

public class Ticket implements Runnable {

//共100票

int ticket = 100;

//定义锁对象

Object lock = new Object();

@Override

public void run() {

//模拟卖票

while(true){

//同步代码块

synchronized (lock){

if (ticket > 0) {

//模拟电影选坐的操作

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);

}

}

}

}

}

当使用了同步代码块后，上述的线程的安全问题，解决了。

4.2.2 同步方法
同步方法：在方法声明上加上synchronized
public synchronized void method(){

可能会产生线程安全问题的代码

}

//同步方法中的锁对象是 this
使用同步方法，对电影院卖票案例中Ticket类进行如下代码修改：

public class Ticket implements Runnable {

//共100票

int ticket = 100;

//定义锁对象

Object lock = new Object();

@Override

public void run() {

//模拟卖票

while(true){

//同步方法

method();

}

}

 

//同步方法,锁对象this

public synchronized void method(){

if (ticket > 0) {

//模拟选坐的操作

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);

}

}

}

静态同步方法: 在方法声明上加上static synchronized
public static synchronized void method(){

可能会产生线程安全问题的代码

}

//静态同步方法中的锁对象是 类名.class
4.3 死锁
同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

synchronzied(A锁){

synchronized(B锁){

}

}
我们进行下死锁情况的代码演示：

定义锁对象类

public class MyLock {

public static final Object lockA = new Object();

public static final Object lockB = new Object();

}

线程任务类

public class ThreadTask implements Runnable {

int x = new Random().nextInt(1);//0,1

//指定线程要执行的任务代码

@Override

public void run() {

while(true){

if (x%2 ==0) {

//情况一

synchronized (MyLock.lockA) {

System.out.println("if-LockA");

synchronized (MyLock.lockB) {

System.out.println("if-LockB");

System.out.println("if大口吃肉");

}

}

} else {

//情况二

synchronized (MyLock.lockB) {

System.out.println("else-LockB");

synchronized (MyLock.lockA) {

System.out.println("else-LockA");

System.out.println("else大口吃肉");

}

}

}

x++;

}

}

}

测试类

public class ThreadDemo {

public static void main(String[] args) {

//创建线程任务类对象

ThreadTask task = new ThreadTask();

//创建两个线程

Thread t1 = new Thread(task);

Thread t2 = new Thread(task);

//启动线程

t1.start();

t2.start();

}
}

4.4 Lock接口
查阅API，查阅Lock接口描述，Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。

Lock接口中的常用方法

image.png

Lock提供了一个更加面对对象的锁，在该锁中提供了更多的操作锁的功能。

我们使用Lock接口，以及其中的lock()方法和unlock()方法替代同步，对电影院卖票案例中Ticket类进行如下代码修改：

public class Ticket implements Runnable {

//共100票

int ticket = 100;

 

//创建Lock锁对象

Lock ck = new ReentrantLock();

 

@Override

public void run() {

//模拟卖票

while(true){

//synchronized (lock){

ck.lock();

if (ticket > 0) {

//模拟选坐的操作

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--);

}

ck.unlock();

//}

}

}

}

1.5 等待唤醒机制
在开始讲解等待唤醒机制之前，有必要搞清一个概念——线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。

等待唤醒机制所涉及到的方法：

wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。

notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。

notifyAll（）： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

其实，所谓唤醒的意思就是让 线程池中的线程具备执行资格。必须注意的是，这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。

仔细查看JavaAPI之后，发现这些方法 并不定义在 Thread中，也没定义在Runnable接口中，却被定义在了Object类中，为什么这些操作线程的方法定义在Object类中？

因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。能被任意对象调用的方法一定定义在Object类中。

image.png

接下里，我们先从一个简单的示例入手:

image.png

如上图说示，输入线程向Resource中输入name ,sex , 输出线程从资源中输出，先要完成的任务是：
1.当input发现Resource中没有数据时，开始输入，输入完成后，叫output来输出。如果发现有数据，就wait();

2.当output发现Resource中没有数据时，就wait() ；当发现有数据时，就输出，然后，叫醒input来输入数据。

下面代码，模拟等待唤醒机制的实现：

模拟资源类

public class Resource {

private String name;

private String sex;

private boolean flag = false;

 

public synchronized void set(String name, String sex) {

if (flag)

try {

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

// 设置成员变量

this.name = name;

this.sex = sex;

// 设置之后，Resource中有值，将标记该为 true ,

flag = true;

// 唤醒output

this.notify();

}

 

public synchronized void out() {

if (!flag)

try {

wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

// 输出线程将数据输出

System.out.println("姓名: " + name + "，性别: " + sex);

// 改变标记，以便输入线程输入数据

flag = false;

// 唤醒input，进行数据输入

this.notify();

}

}

输入线程任务类

public class Input implements Runnable {

private Resource r;

 

public Input(Resource r) {

this.r = r;

}

 

@Override

public void run() {

int count = 0;

while (true) {

if (count == 0) {

r.set("小明", "男生");

} else {

r.set("小花", "女生");

}

// 在两个数据之间进行切换

count = (count + 1) % 2;

}

}

}

输出线程任务类

public class Output implements Runnable {

private Resource r;

 

public Output(Resource r) {

this.r = r;

}

 

@Override

public void run() {

while (true) {

r.out();

}

}

}

测试类

public class ResourceDemo {

public static void main(String[] args) {

// 资源对象

Resource r = new Resource();

// 任务对象

Input in = new Input(r);

Output out = new Output(r);

// 线程对象

Thread t1 = new Thread(in);

Thread t2 = new Thread(out);

// 开启线程

t1.start();

t2.start();

}

}

5.1 知识点总结
同步锁
多个线程想保证线程安全，必须要使用同一个锁对象

同步代码块
synchronized (锁对象){

可能产生线程安全问题的代码

}

//同步代码块的锁对象可以是任意的对象
同步方法
public synchronized void method()

          可能产生线程安全问题的代码

}

//同步方法中的锁对象是 this
静态同步方法
public synchronized void method()

          可能产生线程安全问题的代码

}

//静态同步方法中的锁对象是 类名.class
多线程有几种实现方案，分别是哪几种?
a, 继承Thread类

b, 实现Runnable接口

c, 通过线程池，实现Callable接口

同步有几种方式，分别是什么?
a,同步代码块

b,同步方法

静态同步方法

启动一个线程是run()还是start()?它们的区别?
启动一个线程是start()

区别：

start： 启动线程，并调用线程中的run()方法

run : 执行该线程对象要执行的任务

sleep()和wait()方法的区别
sleep: 不释放锁对象, 释放CPU使用权

在休眠的时间内，不能唤醒

wait(): 释放锁对象, 释放CPU使用权

在等待的时间内，能唤醒

为什么wait(),notify(),notifyAll()等方法都定义在Object类中
锁对象可以是任意类型的对象

码农BookSea
关注
专栏目录
Java程序框架--多线程异步处理多任务
08-15
几乎所有的大型系统都有一个多任务多线程处理内核。本程序提供了一个多任务多线程异步处理框架。该框架使用简单，用户只需要继承抽象类Task,构建自己的任务类，再构造一个任务源，就可以轻松使用这个框架。 程序包里提供了一个例子Mytask 和MyTaskGenerator, 用户只需要运行类bootStraps即可。
java多线程实现大批量数据导入源码
09-29
本项目以"java多线程实现大批量数据导入源码"为题，旨在通过多线程策略将大量数据切分，并进行并行处理，以提高数据处理速度。 首先，我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...
java多线程处理任务
weixin_30532987的博客
06-18 215
最近用到使用多线程处理给用户发送站内消息的问题，想到使用java自带的线程池进行处理这个问题，具体如下： 定义一个线程: package com.qlwb.util; import org.apache.log4j.Logger; import redis.clients.jedis.ShardedJedis; import com.qlwb.common.red...
多线程详细讲解(包含全部内容)
最新发布
qq_51263863的博客
08-12 819
包含了多线程从入门到精通的全部内容
java 多线程处理任务
wodebokecsdn的博客
03-02 611
java 多线程处理任务
JAVA多线程的问题以及处理【转】
hjf19790118的专栏
12-18 747
12.4 多线程问题及处理          多线程编程为程序开发带来了很多的方便，但是也带来了一些问题，这些问题是在程序开发过程中必须进行处理的问题。          这些问题的核心是，如果多个线程同时访问一个资源，例如变量、文件等，时如何保证访问安全的问题。在多线程编程中，这种会被多个线程同时访问的资源叫做临界资源。          下面通过一个简单的示例，演示多个线程访
java多线程执行任务
qq_41062545的博客
07-14 3996
java多线程执行任务
详解Java多线程处理List数据
08-26
详解Java多线程处理List数据 Java多线程处理List数据是指在Java编程中，使用多线程技术来处理List数据的操作。这种操作可以提高程序的执行效率和性能，特别是在处理大规模数据时。下面将详细介绍Java多线程处理List...
JAVA多线程的使用场景与注意事项总结
08-26
JAVA多线程的使用场景与注意事项总结 Java多线程是Java语言中的一种重要机制，允许程序同时执行多个任务，以提高程序的执行效率和响应速度。在Java中，多线程可以通过继承Thread类、实现Runnable接口或使用线程池来...
Java多线程Executors批量执行数据实现限流
05-20
Java多线程实现数据切割批量执行，实现限流操作。 java线程池Executors实现数据批量操作。 批量异步Executors处理数据，实现限流操作，QPS限流。 线程池调用第三方接口限流实现逻辑。 案例适合： 1.批量处理大数据。...
java多线程导出excel（千万级别）优化
12-05
Java多线程导出Excel是处理大数据量时的一种高效策略，尤其在面对千万级别的数据时。传统的Apache POI库在处理大规模数据时可能会遇到栈溢出（StackOverflowError）和内存溢出（OutOfMemoryError）等问题，因为这些...
Java使用多线程（线程池）处理任务
qq_36811160的博客
04-11 249
import lombok.extern.slf4j.Slf4j; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; /** * @Author :ps * @Date :2021/4/3 22:07 * @Description : */ @Slf4j public class ThreadDemo4 { public static void main(String[]
Java多线程处理任务
離殇
03-08 446
Java多线程处理任务 //首先定义一个方法 public String threadDemo() { try { //创建连接池，定义线程数量：10 ExecutorService executorService = Executors.newFixedThreadPool(10); //调用execute()函数执行任务的加载 executorService.execute(() -> { //此处定义要执行的逻辑代码 System.out.println(“线程执行
java多线程处理任务【原】
请叫我杰哥
06-23 8222
 <strong style="mso-bidi-font-weight:normal">Java<span style="font-size:16.0pt;font-family:宋体;mso-ascii-font-family:Calibri;mso-ascii-theme-font:minor-latin;mso-fareast-font-family:宋体;mso-fare
Java中的多线程处理
weixin_44297161的博客
09-06 942
进程与线程 进程 是指内存中运行的应用程序，每个进程都有独立的内存空间 线程 是进程执行的一个路径，共享一个内存空间，线程之间可以自由切换，并发执行 2.一个进程最少有一个线程 3.线程实际上是进程基础之上的进一步划分，一个进程里的若干个路径可划分成若干个线程 两者的异同与联系 相同点： 两者是操作系统程序运行时的基本单位，实现系统对应用的并发行性 不同点： 1.进程是系统资源分配和调度的最小单位，线程是系统运算调度的最小单位 2.进程可以并发执行多个线程，线程则是组成进程的重要部分 3.相对于进程而言，一
java线程能做什么_java中的多线程能做什么 ？基本作用能说下吗？
weixin_35843830的博客
02-24 206
该楼层疑似违规已被系统折叠隐藏此楼查看此楼给你写个最简单的多线程分同步和异步的,我已经给你写上了synchronized,但注释了，你可以顺便看看加上它和去掉他的区别!publicclassThread2{Threadt1=newThread(newRunnable(){publicvoidrun(){m4t1();}},"t1");Threadt2=newT...
java 多任务通过多线程处理demo
cocoaxian的博客
06-29 3435
通过线程可以让多核机器同时完成多条复杂任务，理论来说可以减少将近一半的程序运行时间。通过主线程触发子线程启动，之后主线程等待子线程执行结束的通知，如果所有子线程都完成之后主线程才会继续走下去。 版本1 主线程 package lzx; public class AppStart { protected static int rideResult = 0; ...
Java多线程深度解析
"《Java多线程详解》- 汪文君" 本书是关于Java多线程编程的深度解析，作者汪文君分享了他在工作中和学习中的理解和实践经验。书中内容详细介绍了多线程的基本概念、Java对多线程的支持以及如何在实际编程中运用多...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农BookSea

您的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值