JUC学习笔记（下集）

最新推荐文章于 2022-10-19 09:27:56 发布
最新推荐文章于 2022-10-19 09:27:56 发布
阅读量170 收藏
点赞数
分类专栏： 自我学习 文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41739987/article/details/116459621
版权

JUC并发编程（下集）

前言

本篇文章仅供自己学习使用，参考与B站尚硅谷的JUC并发编程视频整理，如果能对读者有一点点启发，本人深感荣幸！ 该篇是下集
全面发展，一专多能！！！！

6.实现Callable接口

实现Callable接口是创建线程的第三种方式
拓展知识（实现多线程的四种方式）

  1. 继承Thread类
  2. 实现Runnable接口
  3. 实现Callable接口
  4. 线程池

后续有时间会总结一下四种多线程的创建方式并且发布新的笔记类博文

6.1 Callback接口

实现Callable接口和实现Runnable接口的区别：

  1. call方法多了返回值
  2. call方法可以抛出异常
  3. 执行Callable方式，需要FutrueTask类的支持，用来接收运算结果

注：FutureTask接口是Future的实现类 使用get()方法可以获取运算结果 FutureTask 会导致线程阻塞，可以实现闭锁的操作
上代码：

public class TestCallable {
	
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		
		//1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
		FutureTask<Integer> result = new FutureTask<>(td);
		
		new Thread(result).start();
		
		//2.接收线程运算后的结果
		try {
			Integer sum = result.get();  //FutureTask 可用于 闭锁
			System.out.println(sum);
			System.out.println("------------------------------------");
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		}
	}
}

class ThreadDemo implements Callable<Integer>{
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= 100; i++) {
			sum += i;
		}
		return sum;
	}
}

7.Lock同步锁

7.1 解决多线程安全问题的方式

有三种解决方案，如下：

  1. 同步代码块
  2. 同步方法
  3. 同步锁

在JDK1.5之前使用1和2两种方法，需要使用synchronized关键字，JDK1.5之后有更灵活的方式 Lock，同步代码块和同步方法是隐式锁，同步锁是一个显示锁，需要通过lock方法上锁，并且使用unlock解锁。

注意：使用lock上锁后必须在finally块中使用unlock进行释放锁

7.2 使用lock操作的实际代码

public class TestLock {
	
	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		
		new Thread(ticket, "1号窗口").start();
		new Thread(ticket, "2号窗口").start();
		new Thread(ticket, "3号窗口").start();
	}
}

class Ticket implements Runnable{
	
	private int tick = 100;
	
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while(true){
			// 上锁
			lock.lock(); 
			try{
				if(tick > 0){
					try {
						Thread.sleep(200);
					} catch (InterruptedException e) {
					
					}
					
					System.out.println(Thread.currentThread().getName() + " 完成售票，余票为：" + --tick);
				}
			}finally{
				// 必须执行 因此放在finally中 释放锁
				lock.unlock(); 
			}
		}
	}
}

7.3 虚假唤醒的解决方案

从消费者和生产者的示例中可以得知 解决虚假唤醒的方案是将wait方法放入循环中，出现虚假唤醒的原因为if中wait被唤醒会继续执行，然而while中调用wait被唤醒会重新执行判断条件，贴一张CSDN大佬的评论图在这里插入图片描述

上代码：

package cn.atguigu.juc;

/*
 * 虚假唤醒的解决：
 *  wait要始终保证在while循环当中。
 */
public class LockTest {
    public static void main(String[] args) {
        Clerk clerk = new Clerk();
        Producter producter = new Producter(clerk);
        Customer customer = new Customer(clerk);

        new Thread(producter,"生产者A").start();
        new Thread(customer,"消费者A").start();
        new Thread(producter,"生产者B").start();
        new Thread(customer,"消费者B").start();
    }
}

// 售货员
class Clerk {
    private int product = 0;

    // 进货
    public synchronized void add() {
        // 产品已满
        while (product >=1) {
            System.out.println(Thread.currentThread().getName() + ": " + "已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        ++product;
        // 该线程从while中出来的时候，是满足条件的
        System.out.println(Thread.currentThread().getName() + ": " +".....进货成功，剩下"+product);
        this.notifyAll();
    }

    // 卖货
    public synchronized void sale() {
        while (product <=0) {
            System.out.println(Thread.currentThread().getName() + ": " + "没有买到货");
            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }
        --product;
        System.out.println(Thread.currentThread().getName() + ":买到了货物，剩下 " + product);
        this.notifyAll();
    }
}

// 生产者
class Producter implements Runnable {
    private Clerk clerk;

    public Producter(Clerk clerk) {
        this.clerk = clerk;
    }

    // 进货
    @Override
    public void run() {
        for(int i = 0; i < 20; ++i) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            clerk.add();
        }
    }
}

// 消费者
class Customer implements Runnable {
    private Clerk clerk;
    public Customer(Clerk clerk) {
        this.clerk = clerk;
    }

    // 买货
    @Override
    public void run() {
        for(int i = 0; i < 20; ++i) {
            clerk.sale();
        }
    }
}

7.4 Condition 控制线程通信

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用 法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。

在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是 await、signal 和 signalAll。

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用Lock其 newCondition() 方法获取Condition实例

8 ReadWriteLock 读写锁

ReadWriteLock 是一对相关的锁，一个用于读操作， 另一个用于写操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的不变性 可以完全不需要考虑加锁操作。

8.1 读写锁常用方法

  1. readLock() // 获取读锁 “非互斥锁”
  2. writeLock() // 获取写锁 “互斥锁”

9 线程八锁

线程八锁是八种使用多线程锁的常用情况，核心是为了证明两点，这里只阐述结论，不做具体例子代码

  1. 非静态方法的默认锁是this，静态方法的默认锁是class
  2. 某一时刻内，只能有一个线程有锁，无论几个方法

10 线程池

线程池是第四种创建多线程的方式，提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁，可以提高响应速度，通常使用Executors工厂方法配置

10.1 线程池的体系结构

java.util.concurrent.Executor ：负责线程的使用与调度的根接口
|-- ExecutorService 子接口：线程池的主要接口
|-- ThreadPoolExecutor 实现类：线程池的实现类
|-- ScheduledExecutorService 子接口 ： 负责线程调度
|-- ScheduledThreadPoolExecutor ：继承了ThreadPoolExecutor，实现了ScheduledExecutorService

10.2 Executors工具类常用方法

newFixedThreadPool() ：创建固定大小的线程池
newCachedThreadPool() ：缓存线程池，线程池的数量不固定，可以根据需求自动更改
newSingleThreadExecutor() ： 创建单个线程池，线程池只有一个线程
newScheduledThreadPool() ： 创建单个固定大小的线程池，可以延迟或定时的任务

10.3 线程池与Callable联合使用示例

public class TestThreadPool {
	
	public static void main(String[] args) throws Exception {
		//1. 创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);
		
		List<Future<Integer>> list = new ArrayList<>();
		
		for (int i = 0; i < 10; i++) {
			Future<Integer> future = pool.submit(new Callable<Integer>(){

				@Override
				public Integer call() throws Exception {
					int sum = 0;
					
					for (int i = 0; i <= 100; i++) {
						sum += i;
					}
					return sum;
				}
				
			});

			list.add(future);
		}
		// 关闭连接
		pool.shutdown();
		
		for (Future<Integer> future : list) {
			System.out.println(future.get());
		}

10.4 线程调度

使用Executors.newScheduledThreadPool()方法进行线程调度 代码如下

public class TestScheduledThreadPool {

	public static void main(String[] args) throws Exception {
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
		
		for (int i = 0; i < 5; i++) {
			Future<Integer> result = pool.schedule(new Callable<Integer>(){

				@Override
				public Integer call() throws Exception {
					int num = new Random().nextInt(100);//生成随机数
					System.out.println(Thread.currentThread().getName() + " : " + num);
					return num;
				}
				
			}, 1, TimeUnit.SECONDS);   //延迟线程，延迟时间，时间单位
			
			System.out.println(result.get());
		}
		pool.shutdown();
	}
}

11 ForkJoinPool 分支/合并框架 工作窃取

11.1 Fork/Join 框架

在这里插入图片描述

11.2 Fork/Join框架和连接池的区别

采用 “工作窃取”模式（work-stealing）：
当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。
相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上。在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中， 如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行。这种方式减少了 线程的等待时间，提高了性能。

以上这段话取自CSDN大佬-- yZzc_XQ 感谢！

完结撒花！！！ 感谢尚硅谷老师，感谢CSDN大佬yZzc_XQ 好好学习天天向上！！

本篇学习笔记成功收尾，下篇中介绍了两种创建线程的方式，分别是实现Callable接口和线程池的方法，并且介绍了Lock线程锁，读写锁，以及线程八锁的情况，每日坚持学习新知识充实自己
人生目标：全面发展，一专多能！！！

超哥CG_544
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC学习笔记 .md
01-31
JUC学习笔记 .md
JUC学习笔记
weixin_44627989的博客
03-27 459
title: JUC相关 欢迎查看Eetal的第八篇博客–JUC相关 JUC JUC是java.util.concurrent的简写,该包下包含一系列java关于多线程协作相关的类 notify和wait notify和wait为Object的方法,需要当前线程持有该对象锁,没有调用则会排除非法监管状态的异常,wait使得当前线程放弃该对象锁,进入条件等待队列,notify从该对象锁的条件等待队...
JUC 并发编程学习笔记（总）
Java技术一点通
10-19 2196
JUC指的就是工具包的简称，里面的工具类可以很方便的实现多线程的开发。java.util工具包、包、分类。业务：普通的线程代码 Thread。Runnable没有返回值、效率相比Callable相对较低！
JUC学习笔记及拓展
yZzc_XQ的博客
06-05 2877
JUC学习笔记及拓展Java JUC1 Java JUC简介2 volatile 关键字-内存可见性2.1 内存可见性2.2 volatile 关键字3 原子变量与CAS算法3.1 原子变量3.1.1 i++的原子性问题3.1.2 原子变量3.2 CAS算法3.2.1 ABA问题3.2.2 CAS在JAVA中底层的实现3.3 原子性与可见性区别4 ConcurrentHashMap4.1 锁粒度4.2 锁分段4.3 其它4.4 写入并复制5 CountDownLatch(闭锁)5.1 概念5.2 方法介绍6
Java 之 JUC 学习笔记
weixin_44583135的博客
12-10 137
JUC 简介 在 Java 5.0 提供了 java.util.concurrent(简称JUC)包,在此包中增加了在并发编程中很常用的工具类, 用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;还提供了设计用于多线程上下文中 的 Collection 实现等; volatile 关键字 volatile 关键字: 当多个线程进行操作共享数据时,可以保证内存中的数据是可见的;相较于 synchronized 是一种 较为轻量级的同步策略; volatile 不具备"互斥性"; v.
JUC快速学习笔记
qq_50665031的博客
07-20 1888
JUC是指javaUtil包中的三个操作线程的包!
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
JUC学习笔记~~~~
03-18
JUC学习笔记，学习于狂神说JavaUp主
自学的JUC学习笔记.md
12-01
总结了个人自学的JUC学习笔记，个人主页可以查看的到。
个人学习-JUC-笔记
02-25
尚硅谷周阳老师的juc课程
idea开启maven多线程编译的方法
超哥的博客
04-23 6403
Maven3支持了多线程编译，可以加快程序构建速度，在IDEA进行如下设置即可 如图： 1C的含义是1倍CPU核心数量，假设我的设备是i7-9750h处理器 6核 就会开启六线程编译 亲测一个项目未开启多线程的时候需要构建3分12秒 开启后1分56秒 大概可以提速百分之50以上！ ...
自我学习：IDEA中常用的几种断点
超哥的博客
03-27 1461
IDEA中几种Debug的方式 首先感谢B站大佬御风大世界，本篇文章是看了他的视频，做一个记录，由于没有原文章，自行总结，所以标明原创。 首先第一种就是正常的逐行Debug，这种没有什么好说的，一行一行走 第二种是断点打到方法上，会自动在方法第一行l和方法最后一行停住，方便查看方法内的全部数据以及返回值是否正确，还有一个用法，将断点打到接口的方法上，执行到具体实现类会自动停住，有多个实现类的时候挺方便的 第三种是异常断点，顾名思义出现指定类型的异常，就会在出现异常的那一行停住，具体设计方式如
MyBatis传递参数的三种方式
超哥的博客
11-16 650
引出问题：在一些需要参数的SQL语句中，如何在MyBatis中实现？ 解决方案 传一个参数 使用MySQL中的concat函数 进行字符串拼接 例 columnName LIKE CONCAT (’%’,‘xxxx’,’%’) 在MyBatis的映射文件中创建select标签 使用#{}的方式使用参数 贴代码 /* resultType是返回类型 使用typeAliases 设置别名 可以写别名 parameterType是参数类型 可以省略 */ <select id="getUser
Maven整合SSM依赖pom.xml文件 --- 有问题版本
超哥的博客
12-04 271
导语：使用Maven的过程中，很痛苦的一件事就是配置依赖，本人整合了一个SSM的环境，包含27个依赖性，通用性还算可以，分享pom文件，希望可以帮助有需要的人。 版本说明：使用的Spring版本为3.2.13.RELEASE，使用MyBatis版本为3.2.2，贴出部分为dependencies标签中的依赖，并非全部pom.xml文件 特别说明：本人将每条依赖都打了注释，部分注释内容取自于百度匿名回答，剩余原创，本文标为原创文章，如有侵权，请联系本人删除或注明出处！ <dependencies
数据结构自学笔记（2）-- 使用数组模拟队列
超哥的博客
05-14 241
数据结构第二节-- 使用数组模拟队列使用数组模拟队列思路分析思路图代码实现使用数组模拟环形队列思路分析思路图代码实现 首先定义三个变量 maxSize代表数组最大容量，front代表头指针，rear代表尾指针 使用数组模拟队列 思路分析 首先应该有一个队列最大长度 其次 应该创建头尾两个指针 其中初始化的时候头尾指针都指向-1 头指针不包含第一个数据 尾指针包含最后一个数据 入队列时候尾指针自增 出队列时候头指针自增 头指针等于尾指针的时候，代表没有数据 尾指针等于最大长度减一的时候，代表满数据 注
Maven整合SSM依赖pom.xml文件 ---无问题版本
超哥的博客
12-05 186
这个版本为可以运行的，之前的（Maven整合SSM依赖pom.xml文件 — 有问题版本）只是做简单整合，并没有发布项目去测试，抱歉误导大家，这个版本是可以发布项目并成功运行的，废话少说，直接贴代码 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
数据结构自学笔记（1）-- 稀疏数组
超哥的博客
05-14 163
数据结构第一节-- 稀疏数组稀疏数组1.1稀疏数组的介绍1.2 稀疏数组图例1.3 稀疏数组的处理方法1.4 二维数组转换稀疏数组示例1.5 代码演示 稀疏数组 1.1稀疏数组的介绍 当一个数组中大部分元素都是0或者是同一个值的时候，可以使用稀疏数组来保存该数组 1.2 稀疏数组图例 左侧是原始二维数组，右侧是稀疏数组。 1.3 稀疏数组的处理方法 记录一个数组有几行几列，有多少不同的值。 把不同的数据记录在一个小规模的数组中。 1.4 二维数组转换稀疏数组示例 棋盘问题，如图所示，2代表蓝色棋子，1
Java基础部分总结
超哥的博客
09-03 151
编程从入门到弃坑—— Java篇 基础程序设计 标识符 关键字 分支结构 循环结构 面向对象编程 Java高级部分
黑马juc并发编程md笔记
最新发布
09-22
黑马程序员的JUC并发教程一是关于并发编程的课程，包括了进程与线程、并行与并发、Java线程等内容。其中涵盖了创建和运行线程、线程的运行原理、线程的方法、线程状态等知识点。并发是指多个程序在同一时间段内在同一个处理机上运行，而进程是程序加载到内存中运行起来的动态实例，负责加载指令、管理内存、管理IO等任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值