目录
1. 什么是JUC
java.util.concurrent(并发的)
2. 线程与进程
进程:一个程序,例如CSDN.exe、QQ.exe等程序的集合;
一个进程往往可以包含多个线程,至少包含一个!
java默认有几个线程? 2个 main、GC
线程:例如一个Typora进程,里面会包括写入、自动保存(都由线程负责)等线程
对于java而言:Thread、Runnable、Callable
Java真的可以开启线程吗? 开不了
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
// 本地方法,底层的c++,java无法直接操作硬件
private native void start0();
并发、并行
并发编程:并行、并发
并发:多线程交替获取CPU时间片,逻辑上认为同时执行多件事,实际上并非同一时刻(针对于单个CPU而言)
cpu一核,模拟出多条线程,天下武功,唯快不破,快速交替
并行:多个线程同时执行,真正意义上的同时执行(针对于多CPU而言)
并发编程的本质:充分利用cpu的资源
java中线程有几个状态
public enum State {
// 新生
NEW,
// 运行
RUNNABLE,
// 阻塞
BLOCKED,
// 等待
WAITING,
// 超时等待
TIMED_WAITING,
// 终止
TERMINATED;
wait、sleep的区别
1.来自不同的类
wait => Object
sleep => Thread
2.关于锁的释放
wait会释放锁,sleep睡觉了,抱着锁睡觉,不会释放!
wait: 释放锁
sleep: 不释放锁
3.使用的范围是不同的
wait: 必须在同步代码块儿
sleep: 在哪都能执行
4.是否需要捕获异常
wait: 不需要捕获异常
sleep: 必须要捕获异常
3. Lock锁(重点)
传统synchronized关键字
package com.coderzpw.demo;
// 基本买票例子
/**
* 正在的多线程开发,公司中的开发
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
// 并发: 多线程操作同一个资源类,把资源类丢进线程
final Ticket ticket = new Ticket();
// @FunctionalInterface 函数式接口,jdk1.8 lambda表达式 (参数)->{代码}
new Thread(()->{
for (int i=1; i<20; i++){
ticket.sale();
}
},"A").start();
new Thread(()->{
for (int i=1; i<20; i++){
ticket.sale();
}
},"B").start();new Thread(()->{
for (int i=1; i<20; i++){
ticket.sale();
}
},"C").start();
}
}
// synchronized
class Ticket{
private int number = 50;
// 买票的方式
public synchronized void sale(){
if (number>0){
System.out.println(Thread.currentThread().getName()+"卖出了"+(50-number)+"几张票,剩余"+number+"张票");
number--;
}
}
}
lock接口
实现类1:ReentrantLock(可重入锁)
实现类2:ReentrantReadWriteLock -> ReadLock(读-写锁)
实现类3:ReentrantReadWriteLock -> WriteLock(读-写锁)
package com.coderzpw.demo;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicketDemo02 {
public static void main(String[] args) {
// 并发: 多线程操作同一个资源类,把资源类丢进线程
final Ticket2 ticket2 = new Ticket2();
// @FunctionalInterface 函数式接口,jdk1.8 lambda表达式 (参数)->{代码}
new Thread(()->{
for (int i=1; i<20; i++){
ticket2.sale();
}
},"A").start();
new Thread(()->{
for (int i=1; i<20; i++){
ticket2.sale();
}
},"B").start();new Thread(()->{
for (int i=1; i<20; i++){
ticket2.sale();
}
},"C").start();
}
}
/**
* lock三部曲
* 1. new ReentrantLock()
* 2. lock.lock(); // 加锁
* 3. lock.unlock(); // 解锁
*/
class Ticket2{
private int number = 50;
Lock lock = new ReentrantLock();
// 买票的方式
public synchronized void sale(){
lock.lock(); // 加锁
try {
// 业务代码
if (number>0){
System.out.println(Thread.currentThread().getName()+"卖出了"+(50-number)+"几张票,剩余"+number+"张票");
number--;
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock(); // 解锁
}
}
}
公平锁: 排队,先来后到
非公平锁: 可以插队 (默认)
Synchronized 和 Lock的区别
- Synchronized 内置的java关键字; Lock 是一个java接口
- Synchronized 无法判断获取锁的状态; Lock可以判断是否获取到锁
- Synchronized 会自动释放锁; Lock必须手动释放锁,否则就会死锁
- Synchronized 线程1(获取锁,阻塞)、线程2(等待,傻傻的等); Lock锁就不会一直等下去
- Synchronized 可重入锁,不可以中断的,非公平锁; Lock,可重入锁,可以判断锁状态,公平与否可以手动设置(默认非公平)
- Synchronized 适合锁少量的代码同步问题; Lock适合锁大量的同步代码块
锁是什么?如何判断锁的是谁?
4. 生产者与消费者
生产者与消费者问题 Synchronized 版
package com.coderzpw.demo.pc;
/**
* 线程之间的通信问题: 生产者和消费者问题! 等待唤醒、通知唤醒
* 线程交替执行 A B C D 操作同一个变量 coin =0
* A coin +1
* B coin -1
* C coin -1
* D coin +1
*/
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{ // 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{ // 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{ // 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{ // 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class Data{// 数字 资源类
private int coin = 0;
// +1
public synchronized void increment() throws InterruptedException {
while(coin!=0){ // 这里必须要有while ,如果用if的话,当其他地方使用notifyAll()方法后该线程会直接唤醒,
//当该线程抢到锁之后线程就不会再判断是否等待的条件了(所以要用while一直判断),即coin是否=0 就直接调用后面的方法,这时就是不应该
//被唤醒的线程被唤醒了,就会造成线程不安全的现象(这种现象被称为虚假唤醒)
// 等待
this.wait();
}
coin++;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程,我+1完毕了
this.notifyAll();
}
// -1
public synchronized void decrement() throws InterruptedException {
while(coin==0){
// 等待
this.wait();
}
coin--;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程,我-1完毕了
this.notifyAll();
}
}
如果用if判断执行结果:
如果用while判断执行结果:
虚假唤醒:
当一个条件满足时,很多线程都被唤醒了,但是只有其中部分是有用的唤醒,其它的唤醒都是无用功
比如说买货,如果商品本来没有货物,突然进了一件商品,这是所有的线程都被唤醒了
,但是只能一个人买,所以其他人都是假唤醒,获取不到对象的锁
JUC版本的生产者和消费者问题
代码演示
package com.coderzpw.demo.pc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class B {
public static void main(String[] args) {
Data1 data1 = new Data1();
new Thread(()->{ // 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data1.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"A").start();
new Thread(()->{ // 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data1.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"B").start();
new Thread(()->{ // 这个线程执行 -1
for (int i=0; i<5; i++){
try {
data1.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"C").start();
new Thread(()->{ // 这个线程执行 +1
for (int i=0; i<5; i++){
try {
data1.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"D").start();
}
}
class Data1{// 数字 资源类
private int coin = 0;
// 建一个锁对象
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
// condition.await(); 等同于原来的wait方法 等待
// condition.signalAll(); 等同于原来的notifyAll方法 唤醒全部
// condition.signal(); 等同于原来的notify方法 唤醒某一个
// +1
public void increment() throws InterruptedException {
// 业务代码写在try里,解锁写在finally里保证无论怎样都能执行解锁,避免死锁
try {
lock.lock(); // 加锁
while (coin!=0){
// 等待
condition.await();
}
coin++;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程,我+1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock(); // 解锁
}
}
// -1
public synchronized void decrement() throws InterruptedException {
try {
lock.lock();
while (coin==0){
// 等待
condition.await();
}
coin--;
System.out.println(Thread.currentThread().getName()+"=>>"+coin);
// 通知其他线程,我-1完毕了
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
精准唤醒 通过不同的condition对象进行精准唤醒
package com.coderzpw.demo.pc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 要求 A执行完调用B,B执行完调用C,C执行完调用A
*/
public class C {
public static void main(String[] args) {
Data2 data2 = new Data2();
new Thread(()->{
for (int i=0; i<10; i++){
data2.printA();
}
},"A").start();
new Thread(()->{
for (int i=0; i<10; i++){
data2.printB();
}
},"B").start();
new Thread(()->{
for (int i=0; i<10; i++){
data2.printC();
}
},"C").start();
}
}
class Data2{ // 资源类 Lock
public Lock lock = new ReentrantLock(); // 锁对象
public Condition condition1 = lock.newCondition(); // 锁监视器1
public Condition condition2 = lock.newCondition(); // 锁监视器2
public Condition condition3 = lock.newCondition(); // 锁监视器3
private int num = 1; // 1A 2B 3C
public void printA(){
try {
lock.lock();
// 业务, 判断-> 执行 -> 通知
while(num!=1){
// 等待
condition1.await();
}
System.out.println(Thread.currentThread().getName()+"=>>AAAAAA");
// 唤醒,唤醒指定的人,B
num = 2;
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB(){
try {
lock.lock();
// 业务, 判断-> 执行 -> 通知
while(num!=2){
// 等待
condition2.await();
}
System.out.println(Thread.currentThread().getName()+"=>>BBBBBB");
// 唤醒,唤醒指定的人,B
num = 3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC(){
try {
lock.lock();
// 业务, 判断-> 执行 -> 通知
while(num!=3){
// 等待
condition3.await();
}
System.out.println(Thread.currentThread().getName()+"=>>CCCCCC");
// 唤醒,唤醒指定的人,B
num = 1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
5. 8锁现象(锁的八个问题)
如何判断锁的是谁? 对象、Class
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁,就是关于锁的8个问题
* 1. 同一个phone,标准情况下,两个线程先打印“发短信”还是“打电话” 答:先发短信 后打电话
* 2. 同一个phone,sendSms延迟4秒,两个线程先打印什么? 答:先发短信 后打电话 (因为锁的是同一个对象,且调用sleep方法并不会释放锁)
*/
public class Test1 {
public static void main(String[] args) {
Phone phone = new Phone();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(4); // 先睡眠4秒
} catch (InterruptedException e) {
e.printStackTrace();
}
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
class Phone{
// synchronized 锁的对象是方法的调用者!
// 两个方法用的同一个锁,谁先拿到谁执行
public synchronized void sendSms(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 3、同一个phone,增加了一个普通方法后,先打印“发短信”还是“hello”? 答:先hello后发短信
* (因为hello没有加synchronized,没有加锁,不是同步方法,不会受锁的影响。)
* 4、 不同phone,两个对象,两个同步方法,先发短信还是先打电话? 答:先打电话,后发短信 (因为这是两个不同的对象,是不同的两把锁)
*/
public class Test2 {
public static void main(String[] args) {
// 两个对象
Phone2 Phone21 = new Phone2();
Phone2 phone22 = new Phone2();
new Thread(()->{ Phone21.sendSms(); },"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{ phone22.call(); },"B").start();
}
}
class Phone2{
// synchronized 锁的对象是方法的调用者!
// 两个方法用的同一个锁,谁先拿到谁执行
public synchronized void sendSms(){
try { // 调用sendSms的时候 要先睡眠4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 5、增加两个静态的同步方法,只有一个对象,先打印“发短信”还是“打电话”? 答:先发短信后打电话
* 6、两个对象!增加两个静态的同步方法,只有一个对象,先打印“发短信”还是“打电话”? 答:先发短信后打电话(因为锁的是一个类,一个已经占用了类,另一个就只能阻塞)
*/
public class Test3 {
public static void main(String[] args) {
// 两个对象的Class类模板只有一个,static,锁的是Class
Phone3 phone31 = new Phone3();
Phone3 phone32 = new Phone3();
new Thread(()->{ phone31.sendSms(); },"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{ phone32.call(); },"B").start();
}
}
// Phone3唯一的一个class对象
class Phone3{
// synchronized 锁的对象是方法的调用者!
// static 静态方法
// 类一加载就有了! 锁的是Class模板
public static synchronized void sendSms(){
try { // 调用sendSms的时候 要先睡眠4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
package com.coderzpw.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
* 7、一个静态同步方法,一个普通同步方法,一个对象,先打印哪一个? 答:先打电话,后发短信 (因为这两个方法锁的东西是不一样的,一个是类,一个是对象。所以互不影响)
* 8、一个静态同步方法,一个普通同步方法,两个对象,先打印哪一个? 答:先打电话,后发短信 (原因同上)
*/
public class Test4 {
public static void main(String[] args) {
Phone4 phone41 = new Phone4();
Phone4 phone42 = new Phone4();
new Thread(()->{ phone41.sendSms(); },"A").start();
try {
TimeUnit.SECONDS.sleep(1); // 线程休眠一秒 JUC版本的休眠 类似于Thread.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{ phone42.call(); },"B").start();
}
}
// Phone4
class Phone4{
// static 静态同步方法 锁的是Class类模板
public static synchronized void sendSms(){
try { // 调用sendSms的时候 要先睡眠4秒
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
// 普通同步方法、锁的是调用者
public synchronized void call(){
System.out.println("打电话");
}
}
6. 集合类线程不安全(ArrayList、HashSet、HashMap都是线程不安全的)
这图上的集合类之间的关系 不包括java.util.concurrent里面的类
1. List
public class ListTest {
public static void main(String[] args) {
List<String > list = new ArrayList<>();
for (int i=0; i<20; i++){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
package com.coderzpw.demo.unsafe;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* @author 小虎牙
*
* 1. 故障现象
* java.util.ConcurrentModificationException 并发修改异常
* 2. 导致原因
*
* 3. 解决方法
* (1) 使用List<String > list = new Vector<>(); Vector是线程安全的(其源码内部的对集合的读写方法都加了synchronized关键字)
* (2) 使用List<String> list = Collections.synchronizedList(new ArrayList<>()) Collections是集合工具类 Collection是集合的上层接口
* (3) 使用JUC下面的CopyOnWriteArrayList类(写时赋值集合) List<String> list = new CopyOnWriteArrayList<>(); 内部源码只在写方面加了锁
* 4. 优化建议(同样的错误不犯两次)
*/
public class ListTest {
public static void main(String[] args) {
listNotSafe();
}
public static void listNotSafe(){
List<String> list = new CopyOnWriteArrayList<>(); //Collections.synchronizedList(new ArrayList<>());//new Vector<>(); //new ArrayList<>();
for (int i=0; i<20; i++){
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
},String.valueOf(i)).start();
}
}
}
CopyOnWriteArrayList类
2. set
package com.coderzpw.demo.unsafe;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
public class SetTest {
public static void main(String[] args) {
setNotSafe();
}
public static void setNotSafe(){
Set<String> set = new CopyOnWriteArraySet<String>();
for (int i=0; i<20; i++){
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
}
3.map
package com.coderzpw.demo.unsafe;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class MapTest {
public static void main(String[] args) {
mapNotSafe();
}
public static void mapNotSafe(){
Map map = new ConcurrentHashMap();
for (int i=0; i<20; i++){
new Thread(()->{
map.put(Thread.currentThread().getName(),UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}