JUC并发

最新推荐文章于 2024-06-13 19:05:17 发布

QSHigh

最新推荐文章于 2024-06-13 19:05:17 发布

阅读量297

点赞数

分类专栏：进阶Java

本文链接：https://blog.csdn.net/qq_24090609/article/details/114832309

版权

进阶Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1.什么是JUC

在这里插入图片描述

2.线程和进程

进程：一个程序，QQ.exe Music.exe 程序的集合；
一个进程往往可以包含多个线程，至少包含一个！
Java默认有几个线程？ 2 个 mian、GC
线程：开了一个进程 Typora，写字，自动保存（线程负责的）
对于Java而言：Thread、Runnable、Callable

线程有几个状态：

public enum State {
	// 新生
	NEW,
	// 运行
	RUNNABLE,
	// 阻塞
	BLOCKED,
	// 等待，死死地等
	WAITING,
	// 超时等待
	TIMED_WAITING,
	// 终止
	TERMINATED;
}

wait/sleep 区别

1、来自不同的类
wait => Object
sleep => Thread
2、关于锁的释放
wait 会释放锁，sleep 睡觉了，抱着锁睡觉，不会释放！
3、使用的范围是不同的
wait必须在同步代码块中
sleep 可以在任何地方睡
4、是否需要捕获异常
wait 不需要捕获异常
sleep 必须要捕获异常

3.Lock锁（重点）

传统 Synchronized

package com.kuang.demo01;
// 基本的卖票例子
import java.time.OffsetDateTime;
/**
* 真正的多线程开发，公司中的开发，降低耦合性
* 线程就是一个单独的资源类，没有任何附属的操作！
* 1、 属性、方法
*/
public class SaleTicketDemo01 {
public static void main(String[] args) {
// 并发：多线程操作同一个资源类, 把资源类丢入线程
	Ticket ticket = new Ticket();
	// @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
	new Thread(()->{
		for (int i = 1; i < 40 ; i++) {
			ticket.sale();
		}
	},"A").start();
	new Thread(()->{
		for (int i = 1; i < 40 ; i++) {
			ticket.sale();
		}
	},"B").start();
	new Thread(()->{
		for (int i = 1; i < 40 ; i++) {
			ticket.sale();
		}
	},"C").start();
	}
}
// 资源类 OOP
class Ticket {
	// 属性、方法
	private int number = 30;
	// 卖票的方式
	// synchronized 本质: 队列，锁
	public synchronized void sale(){
		if (number>0){
			System.out.println(Thread.currentThread().getName()+"卖出了"+(number)+"票,剩余："+number);
			}
		}
	}

Lock 接口

在这里插入图片描述

公平锁：十分公平：可以先来后到
非公平锁：十分不公平：可以插队（默认）

package com.kuang.demo01;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicketDemo02 {
	public static void main(String[] args) {
		// 并发：多线程操作同一个资源类, 把资源类丢入线程
		Ticket2 ticket = new Ticket2();
		// @FunctionalInterface 函数式接口，jdk1.8 lambda表达式 (参数)->{ 代码 }
		new Thread(()->{
			for (int i = 1; i < 40 ; i++)
				ticket.sale();
			},"A").start();
		new Thread(()->{
			for (int i = 1; i < 40 ; i++)
				ticket.sale();
			},"B").start();
		new Thread(()->{
			for (int i = 1; i < 40 ; i++)
				ticket.sale();
			},"C").start();
		}
	}
// Lock三部曲
// 1、 new ReentrantLock();
// 2、 lock.lock(); // 加锁
// 3、 finally=> lock.unlock(); // 解锁
class Ticket2 {
	// 属性、方法
	private int number = 30;
	Lock lock = new ReentrantLock();
	public void sale(){
		lock.lock(); // 加锁
		try {
			// 业务代码
			if (number>0){
				System.out.println(Thread.currentThread().getName()+"卖出了"+
				(number- )+"票,剩余："+number);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock(); // 解锁
		}
	}
}

Synchronized 和 Lock 区别

1、Synchronized 内置的Java关键字， Lock 是一个Java类
2、Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取到了锁
3、Synchronized 会自动释放锁，lock 必须要手动释放锁！如果不释放锁，死锁
4、Synchronized 线程 1（获得锁，阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下
去；
5、Synchronized 可重入锁，不可以中断的，非公平；Lock ，可重入锁，可以判断锁，非公平（可以
自己设置）；
6、Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码！

4.生产者和消费者问题

生产者和消费者问题 Synchronized 版

package com.kuang.pc;
/**
* 线程之间的通信问题：生产者和消费者问题！ 等待唤醒，通知唤醒
* 线程交替执行 A B 操作同一个变量 num = 0
* A num+1
* B num-1
*/
public class A {
	public static void main(String[] args) {
		Data data = new Data();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.increment();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.increment();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.decrement();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"C").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.decrement();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"D").start();
	}
}
// 判断等待，业务，通知
class Data{ // 数字 资源类
	private int number = 0;
	//+1
	public synchronized void increment() throws InterruptedException {
		//此处应该换成while，防止虚假唤醒
		if (number!=0){ //0
			// 等待
			this.wait();
		}
		number++;
		System.out.println(Thread.currentThread().getName()+"=>"+number);
		// 通知其他线程，我+1完毕了
		this.notifyAll();
	}
	//-1
	public synchronized void decrement() throws InterruptedException {
		if (number==0){ // 1
			// 等待
			this.wait();
		}
		number- ;
		System.out.println(Thread.currentThread().getName()+"=>"+number);
		// 通知其他线程，我-1完毕了
		this.notifyAll();
	}
}

结果分析

上述结果出现了number为2的情况，不符合之前的预期，出现问题的场景是这样的：当number为1的时候，线程A和B先后获取锁去生产数据的时候会被阻塞住，然后消费者C或者D消费掉数据后去notifyAll()唤醒了线程A和B，被唤醒的A和B没有再次去判断number状态，就去执行后续增加数据的逻辑了，导致两个生产者都执行了increment()，最终number出现了2这种情况。也就是说线程A和B有一个是不应该被唤醒的却被唤醒了，出现这个问题的关键点在于程序中使用到了if判断，只判断了一次number的状态，应该使用while循环去判断，可以防止2个线程同时执行了生产功能。

JUC版的生产者和消费者问题

在这里插入图片描述

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
//A，C生产，B，D消费
public class B {
	public static void main(String[] args) {
		Data2 data = new Data2();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.increment();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"A").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.decrement();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"B").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.increment();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"C").start();
		new Thread(()->{
			for (int i = 0; i < 10; i++) {
				try {
					data.decrement();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		},"D").start();
	}
}
// 判断等待，业务，通知
class Data2{ // 数字 资源类
	private int number = 0;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();
	//condition.await(); // 等待
	//condition.signalAll(); // 唤醒全部
	//+1
	public void increment() throws InterruptedException {
		lock.lock();
		try {
			// 业务代码
			while (number!=0){ //0
				// 等待
				condition.await();
			}
			number++;
			System.out.println(Thread.currentThread().getName()+"=>"+number);
			// 通知其他线程，我+1完毕了
			condition.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	//-1
	public synchronized void decrement() throws InterruptedException {
		lock.lock();
		try {
			while (number==0){ // 1
				// 等待
				condition.await();
			}
			number- ;
			System.out.println(Thread.currentThread().getName()+"=>"+number);
			// 通知其他线程，我-1完毕了
			condition.signalAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

执行结果：
在这里插入图片描述

JUC有序执行

A 执行完调用B，B执行完调用C，C执行完调用A

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) {
		Data3 data = new Data3();
		new Thread(()->{
			for (int i = 0; i <10 ; i++) {
				data.printA();
			}
		},"A").start();
		new Thread(()->{
			for (int i = 0; i <10 ; i++) {
				data.printB();
			}
		},"B").start();
		new Thread(()->{
			for (int i = 0; i <10 ; i++) {
				data.printC();
			}
		},"C").start();
	}
}
class Data3{ // 资源类 Lock
	private Lock lock = new ReentrantLock();
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();
	private int number = 1; // 1A 2B 3C
	
	public void printA(){
		lock.lock();
		try {
			// 业务，判断-> 执行-> 通知
			while (number!=1){
				// 等待
				condition1.await();
			}
			System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
			// 唤醒，唤醒指定的人，B
			number = 2;
			condition2.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void printB(){
		lock.lock();
		try {
			// 业务，判断-> 执行-> 通知
			while (number!=2){
				condition2.await();
			}
			System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBB");
			// 唤醒，唤醒指定的人，c
			number = 3;
			condition3.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	public void printC(){
		lock.lock();
		try {
			// 业务，判断-> 执行-> 通知
			// 业务，判断-> 执行-> 通知
			while (number!=3){
				condition3.await();
			}
			System.out.println(Thread.currentThread().getName()+"=>BBBBBBBBB");
			// 唤醒，唤醒指定的人，c
			number = 1;
			condition1.signal();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

5.8锁现象

8锁，就是关于锁的8个问题

1、标准情况下，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话
2、加了方法sendSms延迟4秒，两个线程先打印发短信还是打电话？ 1/发短信 2/打电话，因为线程B访问时，A还在占用中，必须等A执行完释放锁。
synchronized 锁的对象是方法的调用者！

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 */
public class Test1
{
    public static void main(String[] args)
    {
        Phone phone = new Phone();
        //锁的存在
        //1、标准情况每个线程执行同样的代码时，两个线程先打印 发短信 还是 打电话？ 1/发短信 2/打电话
        new Thread(() - >
        {
            phone.sendSms();
        }, "A").start();
        // 捕获
        try
        {
            TimeUnit.SECONDS.sleep(1);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        new Thread(() - >
        {
            phone.call();
        }, "B").start();
    }
}
class Phone
{
    // synchronized 锁的对象是方法的调用者！、
    // 两个方法用的是同一个锁，谁先拿到谁执行！
    //2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
    public synchronized void sendSms()
    {
        try
        {
            TimeUnit.SECONDS.sleep(4);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call()
    {
        System.out.println("打电话");
    }
}

3、增加了一个普通方法后！先执行发短信还是Hello？ Hello
hello()没有锁，所以可以先执行
4、两个对象，两个同步方法，发短信还是打电话？ // 打电话
synchronized 锁的对象是方法的调用者！

import java.util.concurrent.TimeUnit;

public class Test2
{
    public static void main(String[] args)
    {
        // 两个对象，两个调用者，两把锁！
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //锁的存在
        new Thread(() - >
        {
            phone1.sendSms();
        }, "A").start();
        // 捕获
        try
        {
            TimeUnit.SECONDS.sleep(1);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        new Thread(() - >
        {
        	//3.增加了一个普通方法后！先执行发短信还是Hello？
        	//phone2.hello();
            phone2.call();
        }, "B").start();
    }
}
class Phone2
{
    // synchronized 锁的对象是方法的调用者！
    public synchronized void sendSms()
    {
        try
        {
            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");
    }
}

5、增加两个静态的同步方法，只有一个对象，先打印发短信？打电话？
发短信，因为static 静态方法，类一加载就有了！锁的是Class
6、两个对象！增加两个静态的同步方法，先打印发短信？打电话？
发短信

import java.util.concurrent.TimeUnit;
public class Test3
{
    public static void main(String[] args)
    {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        //锁的存在
        new Thread(() - >
        {
            phone1.sendSms();
        }, "A").start();
        // 捕获
        try
        {
            TimeUnit.SECONDS.sleep(1);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        new Thread(() - >
        {
        	//增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？
        	//phone1.call();
            phone2.call();
        }, "B").start();
    }
}
// Phone3唯一的一个 Class 对象
class Phone3
{
    // synchronized 锁的对象是方法的调用者！
    // static 静态方法
    // 类一加载就有了！锁的是Class
    public static synchronized void sendSms()
    {
        try
        {
            TimeUnit.SECONDS.sleep(4);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call()
    {
        System.out.println("打电话");
    }
}

7、1个静态的同步方法，1个普通的同步方法，一个对象，先打印发短信？打电话？
打电话
8、1个静态的同步方法，1个普通的同步方法，两个对象，先打印发短信？打电话？
打电话

import java.util.concurrent.TimeUnit;
/**

 */
public class Test4
{
    public static void main(String[] args)
    {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(() - >
        {
            phone1.sendSms();
        }, "A").start();
        // 捕获
        try
        {
            TimeUnit.SECONDS.sleep(1);
        }
        catch(InterruptedException e)
        {
            e.printStackTrace();
        }
        new Thread(() - >
        {
	        //一个对象时
	        //phone1.call();
            phone2.call();
        }, "B").start();
    }
}
// Phone3唯一的一个 Class 对象
class Phone4
{
    // 静态的同步方法 锁的是 Class 类模板
    public static synchronized void sendSms()
        {
            try
            {
                TimeUnit.SECONDS.sleep(4);
            }
            catch(InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("发短信");
        }
        // 普通的同步方法 锁的调用者
    public synchronized void call()
    {
        System.out.println("打电话");
    }
}

总结：

synchronized 是锁的具体谁调用的-new对象
static 相当于锁了唯一的一个Class模板

6.线程安全的集合类

CopyOnWriteArrayList

并发下 ArrayList 不安全的，Synchronized；
解决方案；

List list = new Vector<>();
JDK1.0-本质是在增删改查都加synchronized，效率低
List list = Collections.synchronizedList(new ArrayList<>
());
也是加synchronized，不建议
List list = new CopyOnWriteArrayList<>()；
用的Lock锁，并且写入时复制，这样查询不用加锁

CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略；
在写入的时候避免覆盖，造成数据查询错乱问题！
CopyOnWrite容器即写时复制的容器。
通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。**这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。**所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

CopyOnWriteArraySet

Set set = Collections.synchronizedSet(new HashSet<>());
Set set = new CopyOnWriteArraySet<>();
public HashSet() {
map = new HashMap<>();
}
// add set 本质就是 map key是无法重复的！
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object(); // 不变得值,常量！

ConcurrentHashMap

HashMap
HashTable
线程安全，但是使用的synchronized,慢
ConcurrentHashMap
ConcurrentHashMap 是由Segment 数组结构和HashEntry数组结构组成。
Segment 是一种可重入锁（ReentrantLock），在ConcurrentHashMap 里扮演锁的角色。
一个ConCurrentHashMap里包含一个 Segment数组。
Segment的结构和HashMap 类似，是一种数组和链表结构。
HashEntry 则用于存储键值对数据。
Get方法没有同步的
在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map

JDK1.7版本锁的粒度是基于Segment的，包含多个HashEntry，而JDK1.8锁的粒度就是HashEntry（首节点）
JAVA7之前ConcurrentHashMap主要采用锁机制，在对某个Segment进行操作时，将该Segment锁定，不允许对其进行非查询操作，而在JAVA8之后采用CAS无锁算法，这种乐观操作在完成前进行判断，如果符合预期结果才给予执行，对并发操作提供良好的优化.
个人理解，相当于加了2次hash的2个数组，先通过hash找到Segment中的位置，再通过hash知道HashEntry中的位置HashEntry[i]，最后通过链表找到。jdk1.7之前是对Segment的一段加锁，现在是对HashEntry首节点加锁，采用CAS无锁算法。

7.Callable

可以有返回值
可以抛出异常
方法不同，run()/call()

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

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

//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//
//            }
//        }).start();

//        new Thread(new FutureTask<>()).start();
        MyThread myThread = new MyThread();
        //适配类
        FutureTask<Integer> futureTask = new FutureTask<>(myThread);
        new Thread(futureTask, "A").start();
        new Thread(futureTask, "B").start();    //结果会被缓存
        //获取callable的返回结果,get可能会产生阻塞，放到最后，或者使用异步通信处理
        Integer o = (Integer) futureTask.get();
        System.out.println(o);


    }

}

class MyThread implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("call()");
        return 1024;
    }
}

细节：

有缓存
结果可能需要等待，会阻塞

8.常用辅助类

8.1 CountDownLatch

简单的计数器

import java.util.concurrent.CountDownLatch;

public class CountDownDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch =new CountDownLatch(6);

        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"Go to");
                countDownLatch.countDown();//减一
            }, String.valueOf(i)).start();

        }
        //等待计数器归零，然后再向下执行
        countDownLatch.await();
        System.out.println("close door");
    }

}

countDownLatch.countDown();//减一
countDownLatch.await();//等待计数器归零，然后再向下执行
每次有线程调用countDowwn() 数量-1，当计数器为0时，countDownLatch.await();就会被唤醒，继续执行。

8.2 CyclicBarrier

package JUC;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(7, ()->{
            System.out.println("召唤神龙成功");
        });

        for (int i = 1; i <= 7; i++) {
            final int temp =i;
            new Thread(() ->{
                System.out.println(Thread.currentThread().getName() + "收集"+ temp+ "个.龙珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

}

8.3 Semaphore

package JUC;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore =new Semaphore(3);

        for (int i = 1; i < 7; i++) {
            new Thread(() ->{
                //acquire()
                //release
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }

    }
}

信号量

semaphore.acquire();
获得,假设如果已经满了,等待,等待被释放为止!
semaphore.release();
释放,会将当前的信号量释放+1,然后唤醒等待的线程!
作用:多个共享资源互斥的使用!并发限流,控制最大的线程数

9. 读写锁

ReadWriteLock
相同的是,读的时候不能写,写的时候不能读
不同的是,读的时候可以多个线程同时占有,写的时候只允许一个线程占有

10. 阻塞队列

写入: 如果队列满了,不得不阻塞
取出: 如果队列空了,不得不阻塞

BlockingQueue

继承非租塞队列AbstractQueue,实现的BlockingQueue阻塞队列接口

什么情况下使用阻塞队列

多线程并发处理,线程池
在这里插入图片描述

使用队列

添加,移除

四组操作API

方式	抛出异常	不会抛出异常,有返回值	阻塞等待	超时等待
添加	add	offer	put	offer(x,x,x)
移除	remove	poll	take	poll(x,x)
判断队列首	element	peek	-	-

抛出异常

    /*抛出异常*/
    public static void test1() {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        System.out.println(blockingQueue.add("1"));
        System.out.println(blockingQueue.add("2"));
        System.out.println(blockingQueue.add("3"));
        //IllegalStateException: Queue full
        System.out.println(blockingQueue.add("d"));
	
		System.out.println(blockingQueue.element());//查看队首元素是谁,会抛出异常

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        //java.util.NoSuchElementException
        System.out.println(blockingQueue.remove());
    }

不会抛出异常,且有返回值

    /*不会抛出异常,且有返回值*/
    public static void test2() {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        System.out.println(blockingQueue.offer("1"));
        System.out.println(blockingQueue.offer("2"));
        System.out.println(blockingQueue.offer("3"));
        System.out.println(blockingQueue.offer("4"));//false 不抛出异常
		System.out.println(blockingQueue.peek());//查看队首元素是谁,返回1
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());//有返回值null
		System.out.println(blockingQueue.peek());//查看队首元素是谁,返回null,不抛出异常
    }

阻塞等待

    /*阻塞等待*/
    public static void test3() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        blockingQueue.put("1");
        blockingQueue.put("2");
        blockingQueue.put("3");
//        blockingQueue.put("4");//阻塞等待直到能放进队列
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());//阻塞等待能取出
    }

超时等待

    /*超时等待*/
    public static void test4() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);
        blockingQueue.offer("1");
        blockingQueue.offer("2");
        blockingQueue.offer("3");
        blockingQueue.offer("4", 2, TimeUnit.SECONDS);//等待超过2秒就退出
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(3, TimeUnit.SECONDS));//等待超过3秒就退出,返回null
    }

同步队列

SynchronousQueue

同步队列是阻塞队列的一种,继承AbstractQueue,实现BlockingQueue接口
没有容量,进去一个元素,必须等待取出来之后,才能往里面放元素!
put/take

package JUC;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

/*
* 同步队列
* 和其他的BlockingQueue不一样,SynchronousQueue 不储存元素
* put了一个元素,必须从里面先take出来,否则不能在put进去值!
* */
public class SynQueue {
    public static void main(String[] args) {
        BlockingQueue<Object> objects = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + " put 1");
                objects.put("1");
                System.out.println(Thread.currentThread().getName() + " put 2");
                objects.put("2");
                System.out.println(Thread.currentThread().getName() + " put 3");
                objects.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + objects.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + objects.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + objects.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();

    }
}

11. 线程池

三大方法/7大参数/4种拒绝策略

池化技术
程序的运行,本质是占用系统的资源!优化资源的使用!=>池化技术
事先准备好一些资源,有人要用,就来我这里拿,用完之后还给我
好处:
1. 降低资源的消耗
2. 提高响应的速度
3. 方便管理

三大方法

        //单个线程
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        //创建一个固定的线程池大小
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        //可伸缩的
        ExecutorService executorService = Executors.newCachedThreadPool();
         for (int i = 0; i < 100; i++) {
		    final int a=i;
		     executorService.execute(() ->{
		         System.out.println(String.valueOf(a)+Thread.currentThread().getName()+" ok");
		     });
		 }
		 executorService.shutdown();

七大参数

三大方法本质都是ThreadPoolExecutor创建的,其中有7大参数

    public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
                              int maximumPoolSize, //最大线程池大小
                              long keepAliveTime,//超时了没有人调用就会释放
                              TimeUnit unit,//超时单位
                              BlockingQueue<Runnable> workQueue,//阻塞队列
                              ThreadFactory threadFactory,//线程工厂,不用动
                              //拒绝策略
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

在这里插入图片描述

四种拒绝策略

new ThreadPoolExecutor.AbortPolicy()); //银行满了,还有人进来,就不处理这个人的,抛出异常(默认)
new ThreadPoolExecutor.CallerRunsPolicy());//哪来的回哪里
new ThreadPoolExecutor.DiscardPolicy());//队列满了,不会抛出异常,丢弃当前任务
new ThreadPoolExecutor.DiscardOldestPolicy());//队列满了,丢弃队列里最老的那个,代替他进入队列,所以可能有任务未执行

在这里插入图片描述
如果使用无界队列很简单，开启核心线程数，多余的全部阻塞直到内存耗尽。
如果使用有界队列，要清楚工作流程：

若有新的任务需要执行，如果线程池实际线程数小于corePoolSize，则优先创建线程，
若大于corePoolSize，则会将任务加入队列，
若队列已满，则在总线程数不大于maximumPoolSize的前提下，创建新的线程，
若线程数大于maximumPoolSize，则执行拒绝策略。或其他自定义方式。

小结拓展

最大线程到底该如何定义

CPU 密集型(任务IO性能好,运行快,等待CPU计算的)
几核就是几,保证CPU效率最好
Runtime.getRuntime().availableProcessors()
IO 密集型(CPU性能比IO好,CPU在等IO设备的)
判断你程序中十分耗IO的线程有多少,一般设置2倍

12. 四大函数式接口(重点)

新时代的程序员:lambda表达式/链式编程/函数式接口/stream流计算
函数式接口: 只有一个方法的接口,超级多,底层大量运用

Function

package JUC.function;

import java.util.function.Function;
/*
* Function 函数型接口,有一个输入参数,有一个输出
* 只要是函数型接口,都可以用lambda表达式简化
* */
public class FunctionDemo {

    public static void main(String[] args) {
        //工具类:输出输入的值
//        Function function = new Function<String, String>() {
//            @Override
//            public String apply(String str) {
//                return str;
//            }
//        };

        Function<String, String> function = (str) ->{
            return str;
        };

        System.out.println(function.apply("asd"));
    }

}

Predicate

package JUC.function;

import java.util.function.Predicate;

/*
* 断定型接口: 有一个输入参数,返回值只能是布尔值
* */
public class PredicateDemo {
    public static void main(String[] args) {
        //判断字符串是否为空
//        Predicate<String> predicate = new Predicate<String>() {
//            @Override
//            public boolean test(String o) {
//                return o.isEmpty();
//            }
//        };
        Predicate<String> predicate = str ->{
            return str.isEmpty();
        };
        System.out.println(predicate.test(""));
    }
}

Consumer

package JUC.function;

import java.util.function.Consumer;

/*
* 消费型接口: 有一个输入参数,返回值只能是布尔值
* */
public class ConsumerDemo {
    public static void main(String[] args) {
        //判断字符串是否为空
        Consumer<String> consumer1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        Consumer<String> consumer2 = str ->{
            System.out.println(str);
        };
        consumer1.accept("1");
        consumer2.accept("2");
    }
}

Supplier

package JUC.function;

import java.util.function.Consumer;
import java.util.function.Supplier;

/*
* 供给型接口: 没有参数,只有返回值
* */
public class SupplierDemo {
    public static void main(String[] args) {
        //判断字符串是否为空
        Supplier supplier1 = new Supplier<Integer>() {
            @Override
            public Integer get() {
                System.out.println("get()");
                return 1024;
            }
        };
        Supplier<Integer> supplier2 = () ->{
            System.out.println("get()");
            return 1024;
        };
        System.out.println(supplier1.get());
        System.out.println(supplier2.get());
    }
}

13. Stream流式计算

大数据:存储+计算
计算应该交给流来操作

package JUC.Stream;

import java.util.Arrays;
import java.util.List;

public class StreamDemo {
    public static void main(String[] args) {
        User u1 = new User(1, "a", 20);
        User u2 = new User(2, "b", 22);
        User u3 = new User(3, "c", 23);
        User u4 = new User(4, "d", 24);
        User u5 = new User(6, "e", 25);

        //集合就是存储
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        //计算交给流 链式编程
        list.stream()
                .filter(u -> {return u.getId()%2 == 0;})
                .filter(u -> {return u.getAge() > 23;})
                .map(u -> {return u.getName().toUpperCase();})
                .sorted((uu1, uu2) -> {
                    return uu1.compareTo(uu2);
                })
                .limit(1)
                .forEach(s -> {
                    System.out.println(s.toString());
                });
    }
}

14. ForkJoin

ForkJoin出现在JDK1.7,并行执行任务!提高效率,大数据量!
大数据: Map Reduce(大任务切成小任务)
特点:工作窃取,维护的是双端队列

package JUC.ForkJoin;

import java.util.concurrent.RecursiveTask;

/*
* 求和计算
* 1.forkjoinPool 通过他来执行
* 2.计算任务forkjoinPool.execute(ForkJoinTask)
* 3.计算类RecursiveTask要继承ForkJoinTask
* */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;
    private Long end;
    private Long temp = 10000L; //临界值

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if ((end - start) > temp) {
            //分支合并计算
            long mide = (start + end) / 2;
            ForkJoinDemo task1 = new ForkJoinDemo(start, mide);
            task1.fork(); //拆分任务,把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(start+1, end);
            task2.fork(); //拆分任务,把任务压入线程队列
            return task1.join() + task2.join();

        } else {
            Long sum = 0L;
            for (Long i = start; i <=end ; i++) {
                sum += i;
            }
//            System.out.println(sum);
            return sum;
        }
    }
}

package com.kuang.forkjoin;

import JUC.ForkJoin.ForkJoinDemo;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;

/**
 * 同一个任务，别人效率高你几十倍！
 */
public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//         test1(); // 12224
         test2(); // 10038
//         test3(); // 153
    }

    // 普通程序员
    public static void test1(){
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    // 会使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);// 提交任务
        Long sum = submit.get();

        long end = System.currentTimeMillis();

        System.out.println("sum="+sum+" 时间："+(end-start));
    }

    public static void test3(){
        long start = System.currentTimeMillis();
        // Stream并行流 ()  (]
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum="+sum+"时间："+(end-start));
    }

}

15. 异步回调

package JUC.future;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * 异步调用： CompletableFuture
 * // 异步执行
 * // 成功回调
 * // 失败回调
 */
public class Demo01 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 没有返回值的 runAsync 异步回调
//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
//        });
//
//        System.out.println("1111");
//
//        completableFuture.get(); // 获取阻塞执行结果

        // 有返回值的 supplyAsync 异步回调
        // ajax，成功和失败的回调
        // 返回的是错误信息；
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            int i = 10/0;
            return 1024;
        });

        System.out.println(completableFuture.whenComplete((t, u) -> {
            System.out.println("t=>" + t); // 正常的返回结果
            System.out.println("u=>" + u); // 错误信息：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 233; // 可以获取到错误的返回结果
        }).get());

        /**
         * succee Code 200
         * error Code 404 500
         */
    }
}

16. JMM

什么是JMM
java内存模型,不存在的东西,概念!约定!

关于JMM的一些同步的约定：
1、线程解锁前，必须把共享变量立刻刷回主存。
2、线程加锁前，必须读取主存中的新值到工作内存中！
3、加锁和解锁是同一把锁
在这里插入图片描述

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

JMM对这八种指令的使用，制定了如下规则：

不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须
write
不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存不允许一个线程将没有assign的数据从工作内存同步回主内存
一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量对一个变量进行unlock操作之前，必须把此变量同步回主内存

问题：程序不知道主内存的值已经被修改过了

17. Volatile

谈谈对Volatile的理解

Volatile是java虚拟机提供的轻量级的同步机制

1. 保证可见性

package JUC.JMM;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    //  不加  volatile  程序就会死循环！
    //  加  volatile  可以保证可见性
    private volatile static int num = 0;

    public static void main(String[] args) {  //  main
        new Thread(() -> { // 线程 1 对主内存的变化不知道的
            while (num == 0) {

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);
    }
}

2. 不保证原子性

原子性 : 不可分割
线程A在执行任务的时候，不能被打扰的，也不能被分割。要么同时成功，要么同时失败。

package JUC.JMM;

import java.util.concurrent.atomic.AtomicInteger;

// volatile 不保证原子性
public class VDemo02 {

    // volatile 不保证原子性
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        // num++; // 不是一个原子性操作
        num.getAndIncrement(); // AtomicInteger + 1 方法， CAS
    }

    public static void main(String[] args) {

        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000 ; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount()>2){ // main  gc
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName() + " " + num);


    }
}

如果不加 lock 和 synchronized ，怎么样保证原子性

使用原子类，解决原子性问题

package JUC.JMM;

import java.util.concurrent.atomic.AtomicInteger;

// volatile 不保证原子性
public class VDemo02 {

    // volatile 不保证原子性
    // 原子类的 Integer
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add(){
        // num++; // 不是一个原子性操作
        num.getAndIncrement(); // AtomicInteger + 1 方法， CAS
    }

    public static void main(String[] args) {

        //理论上num结果应该为 2 万
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000 ; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount()>2){ // main  gc
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName() + " " + num);

    }
}

这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在！

3. 禁止指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行的。
源代码–>编译器优化的重排–> 指令并行也可能会重排–> 内存系统也会重排—> 执行
处理器在进行指令重排的时候，考虑：数据之间的依赖性！

在这里插入图片描述
volatile可以避免指令重排：
内存屏障。CPU指令。作用：
1、保证特定的操作的执行顺序！
2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

Volatile 是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

18. 单例模式

饿汉式

package JUC.Single;

//饿汉式单例
public class Hungry {

    private Hungry() {

    }

    private final static Hungry hungry = new Hungry();

    public static Hungry getInstance() {
        return hungry;
    }

}

DCL懒汉式

package JUC.Single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

//懒汉式单例
public class Lazy {

    private  static  boolean  isExist  =  false;

    private Lazy() {
        synchronized (Lazy.class) {
            if (isExist == false) {
                isExist = true;
            } else {
                throw new RuntimeException("不要试图使用反射破坏单例异常");
            }
        }
    }

    private volatile  static Lazy l;

    //双重检测锁模式的 懒汉式单例 DCL懒汉式单例
    public static Lazy getInstance() {
        if (l == null) {
            synchronized (Lazy.class) {
                if (l == null) {
                    l = new Lazy();  //不是一个原子性操作
                    /*
                    * 1. 分配内存空间
                    * 2. 执行构造方法,初始化对象
                    * 3. 把这个对象指向这个空间
                    *
                    * */
                }
            }
        }
        return l;
    }

    //多线程并发
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        //静态变量增加volatile,获取单例方法双重检测锁模式,基本可以解决多线程环境下单例问题
//        for (int i = 0; i < 10; i++) {
//            new Thread(() -> {
//                Lazy.getInstance();
//            }).start();
//        }


        // 反射！可以破坏单例
        //如果反射获得构造器,虽然构造器私有,但是可以设置权限强行获取,从而破坏单例
        //如下instance0和instance相比返回不同实例,此种情况需要在构造方法里synchronized锁住对象,此时判断实例是否存在,如果存在,则抛出异常,提示防止破坏单例
        Lazy  instance0  =  Lazy.getInstance();
        Constructor<Lazy> declaredConstructor  = Lazy.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        Lazy instance = declaredConstructor.newInstance();
        //此处instance和instance3不是同一个实例,所以可以增加isExist标志变量判断是否存在单例,如果存在则抛出异常,提示防止破坏单例
        Lazy instance3 = declaredConstructor.newInstance();

        //此时加了标志变量也能破解获得不同单例
        Field isExist  =  Lazy.class.getDeclaredField("isExist");
        isExist.setAccessible(true); //破坏private权限
        isExist.set(instance, false);
        //重新设置已存在实例的信号量为false,此时instance0和instance2又不一样
        Lazy  instance2  =  declaredConstructor.newInstance();
        System.out.println(instance0);
        System.out.println(instance2);

        //此时可以考虑枚举

        }

    }

静态内部类实现单例

package JUC.Single;

public class Holder {

    private Holder () {

    }

    public static Holder getInstance() {
        return InnerClass.holder;
    }

    public static class InnerClass {
        private static final Holder holder= new Holder();
    }

}

枚举,真正的单例
枚举实现单例模式：简洁，无偿地提供了序列化机制，由JVM从根本上提供保障，绝对防止多次实例化。线程安全
没有延迟加载

package JUC.Single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

// enum 是一个什么？ 本身也是一个Class类
public enum EnumSingle {

    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }

}

class Test{

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();

        // NoSuchMethodException: com.kuang.single.EnumSingle.<init>()
        //此时已经证明了是真正的单例
        System.out.println(instance1);
        System.out.println(instance2);

    }

}

枚举源码:
在这里插入图片描述

package  com.kuang.single;

public  final  class  EnumSingle  extends  Enum
{

public  static  EnumSingle[]  values()
{
return  (EnumSingle[])$VALUES.clone();
}

public  static  EnumSingle  valueOf(String  name)
{
return  (EnumSingle)Enum.valueOf(com/kuang/single/EnumSingle,  name);
}

private  EnumSingle(String  s,  int  i)
{
super(s,  i);
}

public  EnumSingle  getInstance()
{
return  INSTANCE;
}

public  static  final  EnumSingle  INSTANCE; private  static  final  EnumSingle  $VALUES[];

static
{
INSTANCE  =  new  EnumSingle("INSTANCE",  0);
$VALUES  =  (new  EnumSingle[]  { INSTANCE
});
}
}

19. CAS

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    //  CAS	compareAndSet  :  比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

// 期望、更新
//  public  final  boolean  compareAndSet(int  expect,  int  update)
// 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语！ 

        System.out.println(atomicInteger.compareAndSet(2020,  2021)); System.out.println(atomicInteger.get());
        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe 类

在这里插入图片描述

CAS ：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！
缺点：
1、循环会耗时
2、一次性只能保证一个共享变量的原子性
3、ABA问题

CAS ： ABA 问题（狸猫换太子）

package JUC;

public class CASDemo {
    //  CAS	compareAndSet  :  比较并交换！
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

// 期望、更新
//  public  final  boolean  compareAndSet(int  expect,  int  update)
// 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语！
// ============== 捣乱的线程 ==================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

// ============== 期望的线程 ==================
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());
    }
}

原子引用

解决ABA 问题，引入原子引用！对应的思想：乐观锁！

带版本号的原子操作！

package JUC;

import  java.util.concurrent.TimeUnit;
import  java.util.concurrent.atomic.AtomicStampedReference;
public  class  CASDemo  {
//AtomicStampedReference  注意，如果泛型是一个包装类，注意对象的引用问题

    // 正常在业务操作，这里面比较的都是一个个对象
    static  AtomicStampedReference<Integer>  atomicStampedReference  =  new AtomicStampedReference<>(1,1);

    //  CAS	compareAndSet  :  比较并交换！
    public  static  void  main(String[]  args) {

        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();  //  获得版本号
            System.out.println("a1=>" + stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            atomicStampedReference.compareAndSet(1, 2, atomicStampedReference.getStamp(),
                    atomicStampedReference.getStamp() + 1);

            System.out.println("a2=>" + atomicStampedReference.getStamp());


            System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(),
                    atomicStampedReference.getStamp() + 1));

            System.out.println("a3=>" + atomicStampedReference.getStamp());

        }, "a").start();


        // 乐观锁的原理相同！
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();  //  获得版本号
            System.out.println("b1=>" + stamp);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicStampedReference.compareAndSet(1, 6, stamp, stamp + 1));

            System.out.println("b2=>" + atomicStampedReference.getStamp());

        }, "b").start();
    }
}

注意：
Integer 使用了对象缓存机制，默认范围是 -128 ~ 127 ，推荐使用静态工厂方法 valueOf 获取对象实例，而不是 new，因为 valueOf 使用缓存，而 new 一定会创建新的对象分配新的内存空间；
在这里插入图片描述

21. 各种锁的理解

公平锁、非公平锁

公平锁：非常公平，不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队（默认都是非公平）

public  ReentrantLock()  {  
	sync  =  new  NonfairSync();
}

public  ReentrantLock(boolean  fair)  {
	sync  =  fair  ?  new  FairSync()  :  new  NonfairSync();
}

可重入锁

可重入锁（递归锁）
在这里插入图片描述

Synchronized

package JUC;

import javax.sound.midi.Soundbank;

//  Synchronized
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sms();
        }, "A").start();


        new Thread(() -> {
            phone.sms();
        }, "B").start();
    }
}

class Phone {

    public synchronized void sms() {
        System.out.println(Thread.currentThread().getName() + "sms");
        call();  //  这里也有锁
    }

    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + "call");
    }
}

Lock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(() -> {
            phone.sms();
        }, "A").start();


        new Thread(() -> {
            phone.sms();
        }, "B").start();
    }
}

class Phone2 {
    Lock lock = new ReentrantLock();

    public void sms() {
        lock.lock();  //  细节问题：lock.lock();  lock.unlock();  //  lock  锁必须配对，否则就会死在里面
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "sms");
            call();  //  这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }

    }

    public void call() {

        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

自旋锁

spinlock
在这里插入图片描述
我们来自定义一个锁测试

import  java.util.concurrent.atomic.AtomicReference;

/**
* 自旋锁
*/
public  class  SpinlockDemo  {

	//  int	0
	//  Thread	null
	AtomicReference<Thread>  atomicReference  =  new  AtomicReference<>();
	
	// 加 锁
	public  void  myLock(){
		Thread  thread  =  Thread.currentThread(); 
		System.out.println(Thread.currentThread().getName()  +  "==>  mylock");
		
		// 自旋锁
		while  (!atomicReference.compareAndSet(null,thread)){
		
		}
	}


// 解锁
// 加锁
	public  void  myUnLock(){
		Thread  thread  =  Thread.currentThread(); 
		System.out.println(Thread.currentThread().getName()  +  "==>  myUnlock"); atomicReference.compareAndSet(thread,null);
	}

}

测试

package JUC;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
    //	ReentrantLock  reentrantLock  =  new  ReentrantLock();
    //	reentrantLock.lock();
    //	reentrantLock.unlock();
    
    // 底层使用的自旋锁CAS
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(() -> {
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            lock.myLock();

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }

        }, "T2").start();
    }
}

在这里插入图片描述

死锁

在这里插入图片描述
死锁测试，怎么排除死锁:

package JUC;

import com.sun.org.apache.xpath.internal.SourceTree;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA, lockB), "T1").start();
        new Thread(new MyThread(lockB, lockA), "T2").start();

    }
}

class MyThread implements Runnable {
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "lock:" + lockA + "=>get" + lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() +
                        "lock:" + lockB + "=>get" + lockA);
            }

        }
    }

解决问题

使用 jps -l定位进程号
使用 jstack 进程号 找到死锁问题

QSHigh

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JUC并发

什么是JUC线程和进程进程：一个程序，QQ.exe Music.exe 程序的集合；一个进程往往可以包含多个线程，至少包含一个！Java默认有几个线程？ 2 个 mian、GC线程：开了一个进程 Typora，写字，自动保存（线程负责的）对于Java而言：Thread、Runnable、Callable线程有几个状态：public enum State { // 新生 NEW, // 运行 RUNNABLE, // 阻塞 BLOCKED, // 等待，死死地等 WAIT
复制链接

扫一扫

专栏目录