JUC并发编程01

最新推荐文章于 2023-07-16 21:36:44 发布
原创 最新推荐文章于 2023-07-16 21:36:44 发布 · 157 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#并发编程

1、JUC（Java.util.concurrent）

2、线程和进程

一个进程往往包含多个线程，至少包含一个；
java默认有两个线程？ main；GC
线程：比进程更小的执行单位，
实现线程的三种方式：Thread，Runnable，Callale
Java开启不了多线程

并发和并行
如果多个线程能同时被多个cpu执行，就是并行。
如果多线程被一个cpu轮流着执行就是并发。
并发编程的本质：充分利用CPU的资源
线程的状态
六种状态：NEW、RUNNABLE、BLOCK、WAITING、TIMEWAITING、TERMINATED
wait、sleep
1、来自不同的类：wait属于Object；sleep属于Thread
2、关于锁的释放：wait释放锁；sleep不释放锁
3、使用的范围是不同的：wait只能在同步代码块或同步控制方法中使用；sleep可以在任意位置使用
4、是否需要捕获异常。

3、LOCK锁

synchronized

/**
 - 线程就是一个单独的资源类，没有任何附属操作；
 */
public class SaleTicketDemo01 {
	public static void main(String[] args) {
		// 并发：多线程操作同一个资源类，把资源类丢入线程
		Ticket ticket = new Ticket();
		new Thread(() -> {for (int i = 0; i < 20; i++) ticket.saleTicket();}, "A").start();
		new Thread(() -> {for (int i = 0; i < 20; i++) ticket.saleTicket();}, "B").start();
		new Thread(() -> {for (int i = 0; i < 20; i++) ticket.saleTicket();}, "C").start();
}
//资源类：属性、方法
class Ticket {
	private int number = 1;
	public synchronized void saleTicket() {
		if (number <= 50) {
	System.out.println(Thread.currentThread().getName() + "卖了第" + number + "张票" + "还剩" + (50 - number) + "张票");
			number ++;
		}
	}
}

lock

public class SaleTicketDemo2 {
	public static void main(String[] args) {
		// 并发：多线程操作同一个资源类，把资源类丢入线程
		Ticket01 ticket = new Ticket01();
		new Thread(() -> {for (int i = 0; i < 20; i++) ticket.saleTicket();}, "A").start();
		new Thread(() -> {for (int i = 0; i < 20; i++) ticket.saleTicket();}, "B").start();
		new Thread(() -> {for (int i = 0; i < 20; i++) ticket.saleTicket();}, "C").start();
	}
}
//资源类：属性、方法
class Ticket01 {
	private int number = 1;
	Lock lock = new ReentrantLock();// 创建锁对象
	public void saleTicket() {
		lock.lock();// 加锁
		try {
			// 资源操作，业务代码
			if (number <= 50) {
				System.out.println(
						Thread.currentThread().getName() + "卖了第" + number + "张票" + "还剩" + (50 - number) + "张票");
				number++;
			}
		} finally {
			lock.unlock();// 释放锁
		}
	}
}

公平锁：谁先来是谁的
非公平锁：谁抢到是谁的(默认)；默认是可重入锁
Synchronized和Lock的区别

  • 层面：synchronized属于JVM层面，java关键字；Lock食欲java类
  • 是否可以判断锁的状态？？
  • 锁的释放：Synchronized会自动释放锁，遇到异常会释放锁；Lock需要手动释放，遇到异常容易造成死锁
  • 阻塞时的操作：Synchronizd会一直等待；lock.trylock可以选择不等待
  • 锁的类型：Synchronized是可重入的非公平锁；lock控制公平不公平
  • 适用场景：Synchronized适合少量代码同步问题，Lock适合锁大量的同步代码

4、生产者和消费者问题

面试：单例模式，排序，生产者和消费者，死锁

public class SaleTicket {
	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.increment();},"A").start();;
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.decrement();},"B").start();
	}
}
// 等待，业务，通知
class Ticket{
	private int number = 0;
	public synchronized void increment(){
		if (number != 0) { // 符合条件进入等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		number ++;// 业务
		System.out.println(Thread.currentThread().getName()+"生产了====>"+number);
		this.notifyAll();// 通知其他线程
	}
	
	public synchronized void decrement(){
		if (number == 0) { // 符合条件进入等待，只会判断一次
			try {
				this.wait(); // 等待中，当被唤醒时，会直接向下执行，不会在判断number的值，
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		number --;// 业务
		System.out.println(Thread.currentThread().getName()+"消费了===>" + number);
		this.notifyAll(); // 通知其他线程
	}
}

多个生产者和消费者问题
防止虚假唤醒问题 判断条件时使用while （CAS）
什么是虚假唤醒：

JUC版的生产者和消费者问题
如何学习：
Lock , await ，signalAll
Synchronized，wait，notifyAll

/*简单实现*/
public class SaleTicket2 {
	public static void main(String[] args) {
		Ticket02 ticket = new Ticket02();
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.increment();},"A").start();
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.increment();},"B").start();
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.increment();},"C").start();
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.increment();},"D").start();
		new Thread(()->{for (int i = 0; i <= 2; i++) ticket.decrement();},"E").start();
	}
}
// 等待，业务，通知
class Ticket02{
	private int number = 0;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	public void increment() {
		lock.lock();
		try {
			while (number != 0) {
				condition.await();
			}
			number++;// 业务
	System.out.println(Thread.currentThread().getName() + "生产了====>" + number);
			condition.signalAll();// 通知其他线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void decrement() {
		lock.lock();
		try {
			while (number == 0) {
				condition.await();
			}
			number--;// 业务
	System.out.println(Thread.currentThread().getName() + "消费了===>" + number);
			condition.signalAll(); // 通知其他线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

任何一个新的技术，绝对不是仅仅只是覆盖了原有的技术
实现有序执行：精准的通知和唤醒线程 ABC线程顺序执行

public class SaleTicket2 {
	public static void main(String[] args) {
		Ticket02 ticket = new Ticket02();
		new Thread(()->{for (int i = 1; i <= 3; i++) ticket.printA();},"A").start();
		new Thread(()->{for (int i = 1; i <= 4; i++) ticket.printB();},"B").start();
		new Thread(()->{for (int i = 1; i <= 5; i++) ticket.printC();},"C").start();
	}
}

// 等待，业务，通知
class Ticket02{
	private Lock lock = new ReentrantLock();
	private int number = 1;// 标识位
	Condition conditionA = lock.newCondition();
	Condition conditionB = lock.newCondition();
	Condition conditionC = lock.newCondition();
	
	public void printA() {
		lock.lock();
		try {
			while (number!=1) {
				conditionA.await(); // 等待
			}
			number = 2;// 业务
			System.out.println(Thread.currentThread().getName());
			conditionB.signal();// 通知指定的线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void printB() {
		lock.lock();
		try {
			while (number!=2) {
				conditionB.await();//等待
			}
			number = 3;// 业务
			System.out.println(Thread.currentThread().getName());
			conditionC.signal(); // 通知指定的线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void printC() {
		lock.lock();
		try {
			while (number!=3) {
				conditionC.await();// 等待
			}
			number = 1;// 业务
			System.out.println(Thread.currentThread().getName());
			conditionA.signal(); // 通知指定的线程
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

5、八锁现象

1、synchronized的锁的对象是方法的调用者：同一个对象会相互干扰，两个方法互不干扰。
2、static静态方法的锁的是class：不管是不是同一对象都会干扰。
3、加锁静态方法和加锁普通方法的锁不一样，互不干扰
4、加锁静态方法和无锁普通方法互不干扰
5、加锁普通方法和无锁普通方法互不干扰

6、集合类不安全

扩展：快速失败、安全失败

ArrayList和HashSet
/*单线程下安全、多线程情况下会发生并发修改异常*/
List<String> asList = Arrays.asList("a","b","c");
asList.forEach(System.out::println)

解决多线程情况的List安全问题
1.解决方法一：

List<String> list = Collections.synchronizedList(new ArrayList<String>());
		for (int i = 0; i < 10; i++) {
			new Thread(()->{list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);}).start();
		}

2、解决方法二：

// 写入时复制，COW 计算机程序设计领域的一种优化策略;在写入的时候避免覆盖，造成数据问题;读写分离
// 使用的锁是lock，Vector是synchronized
List<String> list = new CopyOnWriteArrayList<String>();
		for (int i = 0; i < 10; i++) {
			new Thread(()->{list.add(UUID.randomUUID().toString().substring(0,5));
			System.out.println(list);}).start();
		}
HashMap

问题：初始容量16(1<<4)，加载因子0.75f
Map<String,String> map = new HashMap<String,String>();// 相当于 new HashMap<String, String>(16,0.75)
？官方文档查看ConcurrentHashMap
1、解决方法一：

Map<Object, String> map = Collections.synchronizedMap(new HashMap<Object, String>());
		for (int i = 0; i < 100; i++) {
			new Thread(()->{map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
			System.out.println(map);}).start();
		}

2、解决方法二：

Map<Object, String> map = new ConcurrentHashMap<Object, String>();
		for (int i = 0; i < 100; i++) {
			new Thread(()->{map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
			System.out.println(map);}).start();
		}
JUC --- Lock锁机制
记得开心一点嘛的博客
10-21 1092
使用进行开发，可以帮助我们在多线程和并发编程中更高效地管理线程和同步操作。JUC提供了多种用于处理并发问题的工具，例如线程池、同步工具、原子类、锁等。在Java的并发编程中，合理使用这些工具可以提高应用的性能和稳定性。在Java中，Lock接口是包的一部分，提供了比关键字更灵活的锁机制。Lock提供了可重入、可中断的加锁机制，并且可以手动控制锁的获取与释放。阻塞线程指的是线程由于某种原因（如等待资源、锁或I/O操作）进入无法继续执行的状态，直到某个条件被满足或事件完成。
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
synchronized 和 lock 区别
zhangqiang180的博客
06-05 171
传统的 synchronized 题目：三个售票员 卖出 30张票 ： 1. 在高内聚低耦合的前提下， 线程 操作(对外暴露的调用方法) 资源类 传统的 synchronized package juc; public class SaleTicketDemo1 { public static void main(String[] args) { Ticket ticket=new Ticket(); new Thread(()->{
深入分析JUC之Lock接口
zjjcchina的博客
01-17 231
锁是用来控制多个线程访问共享资源的方式，在Lock之前，锁功能是靠synchronized实现的，Lock既然能出现，肯定是synchronized在有些情况下满足不了，我们来对比下两者的异同： 一、实现原理 synchronized,通过monitorenter/monitorexit两个指令来实现的，前者指令是在编译后插入到同步代码块开始位置，而后者指令是插入到方法结束和异常处，任何一个对象都有一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。 lock,主要通过同步器
Synchronized和Lock的区别
一路的博客
06-07 879
我们从下列几点来介绍下Synchronized和lock的区别 1.原始构造 synchronized是关键字，属于JVM层面；使用monitorenter和monitorexit（底层是通过monitor对象来完成；其wait/notify等方法也依赖于monitor对象，只有在同步代码块或者同步方法中才能调用wait/notify等方法。 额外提一句：反编译synchronized底层中有一个monitorenter,两个monitorexit,一个monitorexit是正常退出解锁，另外一个是异常情
synchroized与Lock的区别
HAN&BLOG
07-16 433
可以充当公平锁，也可以当非公平锁，且Lock锁一旦出现异常就会非常麻烦，所以必须。，且synchroized不用关闭，如果出现异常，底层jvm会帮忙自动关闭。，所以是在底层的jvm（java虚拟机）实现的。，通常写在finally中，一定会被执行。，是jdk5.0提供的，是一个。，是jdk1.5提供的。
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
精选资源
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
JUC并发编程与源码分析视频课.zip
12-16
《JUC并发编程与源码分析视频课》是一门深入探讨Java并发编程的课程，主要聚焦于Java Util Concurrency（JUC）库的使用和源码解析。JUC是Java平台提供的一组高级并发工具包，它极大地简化了多线程编程，并提供了更...
JUC之Lock接口
weixin_38568503的博客
03-04 3228
说明:sync的上锁和解锁是自动完成的，当然我们也可以手动上锁和解锁 Lock和synchronized的选择 总结来说，Lock和synchronized有以下几点不同： 1）Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现； 2）synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在fi...
Java学习 --- JUC的lock接口
qq_46093575的博客
03-22 704
一、juc的概述 在 Java 5.0 提供了 java.util.concurrent （简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的 Collection 实现等。 二、线程 1、用户线程 package com.cjc.juc; public class Main { public static void main(String[
JAVA JUC 之 Lock接口及其实现（下）
tongkp的专栏
07-25 246
在上一篇博文中跟大家分享了java juc包中的lock锁的lock、tryLock、tryLock（带超时时间的）、lockInterruptibly这四个方法。 这里要和大家分享的是java juc包中的lock锁的newCondition()方法，我这里写了一段基于Condition的ReentrantLock 实现的阻塞队列的读写锁操作，废话少说，直接看代码 import java.util.ArrayList; import java.util.List; import java.util.
【JUC-01】JUC—lock接口及AQS核心知识讲解
大黄奔跑
12-09 1024
1. lock接口 Lock接口作为锁的基础接口，具有锁基本功能，下面针对于源码分析一些基本的用法： public interface Lock { /** * 获取锁 * 调用该方法的当前线程将会获取锁，当锁获得之后，从该方法返回 */ void lock(); /** * 可中断的获取锁 * 和lock()方法不同之...
synchronized和Lock的区别是什么？
这个人很懒，什么都没有留下。
04-11 2万+
区别：1、lock是一个接口，而synchronized是java的一个关键字。2、synchronized在发生异常时会自动释放占有的锁，因此不会出现死锁；而lock发生异常时，不会主动释放占有的锁，必须手动来释放锁，可能引起死锁的发生。 在分布式开发中，锁是线程控制的重要途径。Java为此也提供了2种锁机制，synchronized和lock。 0、synchronized实现原理 Java中每一个对象都可以作为锁，这是synchronized实现同步的基础： 普通同步方法，锁是当前.
详解synchronized与Lock的区别与使用
热门推荐
brickworkers的博客
03-22 21万+
引言： 昨天在学习别人分享的面试经验时，看到Lock的使用。想起自己在上次面试也遇到了synchronized与Lock的区别与使用。于是，我整理了两者的区别和使用情况，同时，对synchronized的使用过程一些常见问题的总结，最后是参照源码和说明文档，对Lock的使用写了几个简单的Demo。请大家批评指正。 技术点： 1、线程与进程： 在开始之前先把进程与线程进行区分一下，一个程序最...
synchronized 和Lock区别
洞玄之境的博客
09-04 12万+
区别如下： 来源： lock是一个接口，而synchronized是java的一个关键字，synchronized是内置的语言实现； 异常是否释放锁： synchronized在发生异常时候会自动释放占有的锁，因此不会出现死锁；而lock发生异常时候，不会主动释放占有的锁，必须手动unlock来释放锁，可能引起死锁的发生。（所以最好将同步代码块用try catch包起来，finall...
java并发编程（四）----（JUC）Lock锁初探
a2225791的博客
12-26 324
首先我们来回忆一下上一节讲过的synchronized关键字，该关键字用于给代码段或方法加锁，使得某一时刻它修饰的方法或代码段只能被一个线程访问。那么试想，当我们遇到这样的情况：当synchronized修饰的方法或代码段因为某种原因（IO异常或是slee...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值