Java学习之Thread之Join、【Monitor】与【wait】与【notify】与【sleep】_加【Callable】【Executor】【ExecutorService】【Future】

已于 2022-05-17 07:07:00 修改
阅读量798 收藏 1
点赞数 1
分类专栏： java 文章标签： 开发语言 后端
于 2022-01-16 23:57:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxzlc/article/details/122531073
版权

目录

■示例代码

代码（Join）

结果

■基础

【相同点】

【不同的】

■代码示例1（生产者与消费者）

0.ProductTest.java

1.Clerk.java

2.Consumer.java

3.Producer.java

■其他：代码示例2：（sleep，join）

■其他：线程的名字

■Callable、ExecutorService、Future

继承关系

示例代码

Callable和Future，一个产生结果，一个拿到结果。

FutureTask

■示例代码

代码（Join）

package com.sxz.study.thread;

public class ThreadJoinStudy {
	
    public static void main(String[] args) throws InterruptedException {
    	System.out.println("Main thread Start...");

        Thread threadB = new Thread(() -> {
        	System.out.println("Thread B Start...");
            for (int i = 0; i < 5; i++) {
            	System.out.println("Thread B Execute...");
            }
            System.out.println("Thread B End...");
        });

        threadB.start();
        // Thread B 加入 Main thread 流程
        // ★　实现了Runnable接口的类，没法使用jion方法
        threadB.join(); 

        System.out.println("Main thread End...");
    }

}

结果

Main thread Start...
Thread B Start...
Thread B Execute...
Thread B Execute...
Thread B Execute...
Thread B Execute...
Thread B Execute...
Thread B End...
Main thread End...

===

■基础

进程：Process

线程：Thread

【相同点】

都会让线程进入阻塞（Blocked）状态

【不同的】

1.每一个Object对象，都有一个锁，【wait】会释放锁，【sleep】不会释放锁。（即，不会释放同步监视器）

详细解释
1.Monitor是一种用来实现同步的工具 （锁：【同步监视器】）
2.与每个java对象相关联，即每个java对象都有一个Monitor与之对应
3.Monitor是实现Sychronized(内置锁)的基础

  2.【wait】与【notify】是Object的方法。【sleep】是Thread的方法。

 3.【wait】与【notify】只能用于 【synchronized】同步块中

    【sleep】在任何地方都可以使用。

    （只是，【sleep】会抛出【InterruptedException】异常）

   JVM启动【main方法】，相当于启动了一个【主线程】。主线程，也就是负责执行main方法中的代码。所以

                   main中，可以sleep

                   main中，【Thread.currentThread().getName()】 ，可以得到值「main」

4.【wait】释放锁，解除对当前操作对象的占用，

5.关于阻塞后的唤醒：【sleep】自动唤醒。被【wait】的，需要其他【synchronized】同步块中，使用【notify】或【notifyAll】方法来唤醒。

6.唤醒 与 锁的释放

调用notify()并不立即释放锁。它只是告诉某个正在等待的线程可以被唤醒，当同步快的所有代码执行完之后，锁才会被真正释放。

7.   用法（套路）
　　一般的用法【等待-通知机制】，套路如下：
　　1、Thread1中判断某一条件不成立while(!【condition】)，然后调用wait()方法。
　　2、Thread2中建立该条件如【condition】=true，然后调用notify()。
       ※【condition】是同一对象中的变量。（即， Thread1，2同时操作同一对象）

■代码示例1（生产者与消费者）

0.ProductTest.java

package com.sxz.study.thread;
 
public class ProductTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk(); 
 
        // 生产者线程
        Thread producerThread = 
            new Thread(
                new Producer(clerk)); 
        // 消费者线程
        Thread consumerThread = 
            new Thread(
                new Consumer(clerk)); 
 
        producerThread.start(); 
        consumerThread.start(); 
    }
}

1.Clerk.java

package com.sxz.study.thread;
 
public class Clerk {
    // -1 表示目前没有产品
    private int product = -1; 
 
     // 这个方法由生产者调用
    public synchronized void setProduct(int product) { 
        if(this.product != -1) { 
            try { 
              // 目前店员没有空间收产品，请稍候！
                wait(); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
 
        this.product = product; 
        System.out.printf("生产者设定 (%d)%n", this.product); 

      // 通知等待区中的一个消费者可以继续工作了
        notify(); 
    } 
    
    // 这个方法由消费者调用
    public synchronized int getProduct() { 
        if(this.product == -1) { 
            try { 
                  // 缺货了，请稍候！
                wait(); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 
        } 
 
        int p = this.product; 
        System.out.printf("消費者取走 (%d)%n", this.product); 
        this.product = -1; // 取走产品，-1表示目前店员手上无产品
 
         // 通知等待区中的一个生产者可以继续工作了
        notify(); 
       
        return p; 
    } 
}

2.Consumer.java

package com.sxz.study.thread;
 
public class Consumer implements Runnable {
    private Clerk clerk; 
    
    public Consumer(Clerk clerk) { 
        this.clerk = clerk; 
    } 
    
    public void run() { 
        System.out.println(
                "消费者开始消耗整数......"); 

        // 消耗10个整数
        for(int i = 1; i <= 10; i++) { 
            try { 
                 // 等待随机时间
                Thread.sleep((int) (Math.random() * 3000)); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 

              // 从店员处取走整数
            clerk.getProduct(); 
        } 
    } 
 }

3.Producer.java

package com.sxz.study.thread;
 
public class Producer implements Runnable {
    private Clerk clerk; 
    
    public Producer(Clerk clerk) { 
        this.clerk = clerk; 
    } 
    
    public void run() { 
        System.out.println(
                "生产者开始生产整数......"); 

        // 生产1到10的整数
        for(int product = 1; product <= 10; product++) { 
            try { 
                // 暂停随机时间
                Thread.sleep((int) Math.random() * 3000); 
            } 
            catch(InterruptedException e) { 
                e.printStackTrace(); 
            } 
            // 将产品交给店员
            clerk.setProduct(product); 
        }       
    } 
}

---

运行结果

消费者开始消耗整数......
生产者开始生产整数......
生产者设定 (1)
消費者取走 (1)
生产者设定 (2)
消費者取走 (2)
生产者设定 (3)
消費者取走 (3)
生产者设定 (4)
消費者取走 (4)
生产者设定 (5)
消費者取走 (5)
生产者设定 (6)
消費者取走 (6)
生产者设定 (7)
消費者取走 (7)
生产者设定 (8)
消費者取走 (8)
生产者设定 (9)
消費者取走 (9)
生产者设定 (10)
消費者取走 (10)

---

■其他：代码示例2：（sleep，join）

public class ThreadA {
    public static void main(String[] args) {
        System.out.println("Thread A执行");

        Thread threadB = new Thread(new Runnable() { 
            public void run() { 
                try { 
                    System.out.println("Thread B开始.."); 
                    for(int i = 0; i < 5; i++) { 
                        Thread.sleep(1000); 
                        System.out.println("Thread B 执行.."); 
                    }
                    System.out.println("Thread B  即将结束.."); 
                } 
                catch(InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
        });
        
        threadB.start();

        try {
             // Thread B 加入 Thread A
            threadB.join();
        } 
        catch(InterruptedException e) { 
            e.printStackTrace(); 
        } 

        System.out.println("Thread A 执行");
    }
}

---

■其他：线程的名字

// 每个线程，都有自己的名字
// JVM开启了主线程，来运行方法main，主线程也是线程，名字就是“main”    // 代码第6、7行
// 其他新建的线程也有名字，默认“Thread-0”，“Thread-1”...

package com.sxz.study.thread;
 
public class ProductTest {
    public static void main(String[] args) throws InterruptedException {
        Clerk clerk = new Clerk(); 
        Thread t =Thread.currentThread();
        System.out.println("Current Thread: " + t.getName());
 
        // 生产者线程
        Thread producerThread = 
            new Thread(
                new Producer(clerk)); 
        // 消费者线程
        Thread consumerThread = 
            new Thread(
                new Consumer(clerk)); 
 
        producerThread.start(); 
        System.out.println(producerThread.getName());
        System.out.println(consumerThread.getName());
        consumerThread.start(); 
        Thread.sleep(3000);
        System.out.println("Current Thread: " + t.getName());
    }
}

---

Current Thread: main
Thread-0
Thread-1
生产者开始生产整数......
消费者开始消耗整数......
生产者设定 (1)
消費者取走 (1)
生产者设定 (2)
消費者取走 (2)
生产者设定 (3)
Current Thread: main
消費者取走 (3)
生产者设定 (4)
消費者取走 (4)
生产者设定 (5)
消費者取走 (5)
生产者设定 (6)
消費者取走 (6)
生产者设定 (7)
消費者取走 (7)
生产者设定 (8)
消費者取走 (8)
生产者设定 (9)
消費者取走 (9)
生产者设定 (10)
消費者取走 (10)

---

■Callable、ExecutorService、Future

继承关系

示例代码

concurrent  英[kənˈkʌrənt]  adj.同时发生的; 并存的;  // java.util.concurrent.Callable // 线程与并行API

import java.util.concurrent.Callable;

public class CallableDemo implements Callable<Integer> {
	
	private int sum;
	@Override
	public Integer call() throws Exception {
		System.out.println("Callable子线程开始计算啦！");
		Thread.sleep(2000);
		
		for(int i=0 ;i<5000;i++){
			sum=sum+i;
		}
		System.out.println("Callable子线程计算结束！");
		return sum;
	}
}

Callable和Future，一个产生结果，一个拿到结果。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableTest {
	
	public static void main(String[] args) {
		//创建线程池
		ExecutorService es = Executors.newSingleThreadExecutor();
		//创建Callable对象任务
		CallableDemo calTask=new CallableDemo();
		//提交任务并获取执行结果
		Future<Integer> future =es.submit(calTask);
		//关闭线程池
		es.shutdown();
		try {
			Thread.sleep(2000);
		System.out.println("主线程在执行其他任务");
		
		if(future.get()!=null){
			//输出获取到的结果
			System.out.println("future.get()-->"+future.get());
		}else{
			//输出获取到的结果
			System.out.println("future.get()未获取到结果");
		}
		
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("主线程在执行完成");
	}
}

运行

set path=C:\java\java8\bin;%path%

chcp 936

javac -encoding UTF-8 CallableDemo.java
javac -encoding UTF-8 CallableTest.java
java CallableTest

pause;

运行结果

Callable子线程开始计算啦！
主线程在执行其他任务
Callable子线程计算结束！
future.get()-->12497500
主线程在执行完成

--

FutureTask

（FutureTask实现了RunnableFuture接口，而RunnableFuture继承了Runnable和Future）

工作中使用到的单词（软件开发）_sun0322-CSDN博客

ーーー

sun0322
关注
专栏目录
多线程按需顺序执行（Thread.join）
jifeng3321的专栏
09-12 482
在项目中会有线程顺序执行的一些需求，比如...，我要吃早餐，但吃早餐必须要等女朋友做好早餐才能吃，但是在等着的同时我可以做其他的事情，比如看电视，我们写个小demo来看一下： import java.text.SimpleDateFormat; import java.util.concurrent.ExecutorService; import java.util.concurrent.Ex...
JUC并发编程（java.util .concurrent工具包）详解与实例演示
BaiKnow的博客
02-03 1608
JUC 并发编程 作者：pox21s 概述 在Java中，线程部分是一个重点，本篇文章说的是关于线程并发编程。JUC就是java.util .concurrent工具包的简称。这是一个处理线程的工具包，从JDK 1.5开始出现。 1.基本概念 1.1 进程和线程 1.1.1 定义 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个基本单位。 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位。线程自己基本上不拥
Java线程中sleep()、wait()和notify()和notifyAll()、yield()、join()等方法的用法和区别
深蓝色的忧伤
11-03 412
[b]Java线程中sleep()、wait()和notify()和notifyAll()、suspend和resume()、yield()、join()、interrupt()的用法和区别[/b] 从操作系统的角度讲，os会维护一个ready queue（就绪的线程队列）。并且在某一时刻cpu只为ready queue中位于队列头部的线程服务。 但是当前正在被服务的线程可能觉得cpu的服...
Thread的sleep()、join()和wait()
延成的博客
09-09 690
版权声明：本文为延成原创文章，转载请标明出处 1 sleep sleep()会让线程交出CPU的执行权，但是不会释放锁。 public class ThreadSleep { //定义锁 private static final Object LOCK = new Object(); public static void main(String[] args) throws InterruptedException { Thread thread1 = new.
MinerMonitorThread.java 监控线程
weixin_30776273的博客
03-26 85
MinerMonitorThread.java 监控线程 package com.iteye.injavawetrust.miner; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** * 监控线程 * @author Administrator *...
Thread.join()和Object.wait()
qq_46083557的博客
11-16 318
当主线程执行过快，而子线程需要耗费大量的执行时间，但是主线程执行时最后需要使用到子线程的一些结果,而主线程却比子线程先结束，那怎么去用到子线程的结果呐，这时Thread类的join方法就可实现满足上述条件的结果。notify，notifAll()也同理，值得注意的是notify执行后线程不会立即去执行wait后的代码，而是等notify执行完后释放object监视器，释放锁之后重新获得后才会继续执行wait之后的代码。而代码里面的wait就是Object类里的wait()方法。先看不加join的。
Java并发编程之Thread知识整理
u010569015的博客
01-07 1869
Java并发编程之线程知识
JAVA并发编程——源码原理全面剖析与重点梳理
lianghongliang66的博客
05-25 1182
帧与帧栈 每个线程有一块栈内存 每个栈由多个栈帧组成，每个栈帧对应每次方法调用占用的内存 每个线程只能有一个活动栈帧，对应当前正在执行的那个方法 线程上下文切换 线程的CPU时间片用完 垃圾回收 有更高优先级的线程需要运行 线程自己调用了sleep、yield、wait、join、park、synchronized、lock等方法 其中程序计数器的作用 操作系统保存当前线程的状态，记住下一条jvm指令的执行地址，用于恢复线程的状态 PS：状态：程序计数器、栈中每个帧栈的信息 线程状态
Java之JUC
lyw4631的博客
11-02 849
文章目录前置要求线程基础知识复习Futrue和Callable接口从之前的FutureTask说对Future的改进案例精讲-从电商网站的比价需求说CompletableFutrue常用方法CompletableFutrue说说Java"锁"事LockSupport与线程中断Java内存模型值JMMvolatile与Java内存模型 前置要求 线程基础知识复习 Futrue和Callable接口 从之前的FutureTask说 对Future的改进 案例精讲-从电商网站的比价需求说 CompletableF
Java并发与线程
yang_zhen_wei的博客
04-11 867
并行和并发有什么区别？ 并行：是指多个线程任务在不同CPU上同时进行，是真正意义上的同时执行。 并发：是指多个线程任务在同一个CPU上快速地轮换执行，由于切换的速度非常快，给人的感觉就是这些线程任务时在同时进行的，但其实并发只是一种逻辑上的同时进行； 线程和进程的区别？ 调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源 系统
java线程的join，wait，notify深入理解
wjbtian的专栏
02-20 3865
对于thread的理解，一直停留在基本层面，想着加强一下理解。Ok，问题总是有的，当然收获也是美滋滋的。 先从一下demo开始lz的探索之旅，一步步揭开那神秘的面纱。 public class JoinTest implements Runnable{              public static int a = 0;         public void run() {
java thread monitor_java并发系列-monitor机制实现
weixin_39857480的博客
02-13 606
背景在jdk1.6以前synchronized的java内置锁不存在 偏向锁->轻量级锁->重量级锁 的锁膨胀机制，锁膨胀机制是1.6之后为了优化java线程同步性能而实现的。而1.6之前都是基于monitor机制的重量级锁。因为java内部对锁实现的封装，就算现在我们也只需要了解重量级锁就可以了。深入了解monitor机制对学习线程同步非常重要。正文目录什么是monitormonit...
Java Thread Monitor
DGenerationX的专栏
12-14 1405
Thread Monitor Introduction
java 线程join的时候，是如何被notify的
weixin_33933118的博客
06-12 318
2019独角兽企业重金招聘Python工程师标准>>> ...
Java 线程间的通信、协作方式 - join 机制，wait-notify 机制
路的尽头在哪
08-01 261
Java Thread 线程之间的通信和协作方式，介绍 Object 类的 wait，notify 系列方法，Thread 的 join 方法机制。
线程中的join()、wait() 和 notify()详解及练习题
最新发布
qq_44299529的博客
09-06 570
线程中的join()、wait() 和 notify()详解及练习题
Thread 类中的：sleep()，join()，wait()，yield()区别详解
大房子爱生活的博客
03-27 3070
1. sleep()： Thread.sleep(1000)； 在指定时间内让当前执行的线程暂停执行一段时间，让其他线程有机会继续执行，但不会释放对象锁，也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据，不推荐使用，sleep() 使当前线程进入阻塞状态，在指定时间不会执行。 2. wait()： 对象的方法，会释放对象锁 wait()和notify()、notif...
java join notify_Java多线程技术-wait/notify/join
weixin_42509914的博客
02-16 179
wait/notify的作用wait()方法的作用是使当前执行代码的线程进行等待，wait()是Object类的方法，用来将当前线程置入预执行队列中，并且在wait()所在的代码处停止执行，直到接到通知或被中断为止。wait()调用前，必须获得该对象的对象级锁，即只能在同步方法或者同步代码块中调用wait()方法，否则会抛出IllegalMonitorStateException。当wait()执...
Thread类中的方法：join()、sleep()、yield() wait()之间的区别
晴天
10-09 789
参考内容:https://blog.csdn.net/xzp_12345/article/details/81129735 https://www.jianshu.com/p/19f861ab749e join()方法会释放 1. Join()方法 Thread的非静态方法join()让一个线程等待另外一个线程完成才继续执行。如果线程A执行体中调用B...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值