JUC并发学习笔记

JUC

采用源码+文档方式学习

什么是JUC

java.util工具包

并发:多线程操作操作一个资源

cpu一核,模拟多条线程

并行:多个人一起走
CPU多核,多个线程同时运行

Wait和sleep

1、来自不同的类
wait ->Object

sleep -> Thread
2、关于锁的释放
wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放

3、使用的范国是不同的

wait必须在同步代码块中
sleep可以再任何地方睡

4、是否需要捕获异常
Wait不需要捕获异常

//现在也需要了

sleep必须要捕获异常?

锁

传统 Synchronized锁

线程就是一个单独的资源类,没有任何附属的操作

资源类OOP

多线程操作同一个资源类,把资源类丢入线程

// 资源类 OOP
class Ticket {
        // 属性、方法
        private int number = 30;
        // 卖票的方式
        // synchronized 本质: 队列，锁
        public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了"+(number- -)+"票,剩余："+number);
        	}
  }

import java.time.OffsetDateTime;Lock 接口
/**
* 真正的多线程开发，公司中的开发，降低耦合性
* 线程就是一个单独的资源类，没有任何附属的操作！
* 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();
    //同上创建名称为B,C的线程并start
    //--------------省略的另外两个线程
        }
}

}

Lock锁

实现类

默认为非公平锁

// 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(); // 解锁
              }
}

操作代码

//公平锁：十分不公平：可以插队 （默认）
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();
        }

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、生产者和消费者问题
面试的：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题

判断要使用if,不能使用while:见多线程笔记

lock实现

并发资源类

// 判断等待，业务，通知
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 {
l	ock.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();
        }
        }
}

并发访问

package com.kuang.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) {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();
}
}

任何一个新的技术，绝对不是仅仅只是覆盖了原来的技术，优势和补充！

Condition 精准的通知和唤醒线程

condition1.await();

condition2.signal();

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();
}
}

8锁问题

如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！

Callable

1、可以有返回值

2、可以抛出异常

3、方法不同，run()/ call()

public Integer call() {
System.out.println("call()"); // 会打印几个call
// 耗时的操作
return 1024;
}

public class CallableTest {
public static void main(String[] args) throws ExecutionException,
InterruptedException {
// new Thread(new Runnable()).start();
// new Thread(new FutureTask<V>()).start();
// new Thread(new FutureTask<V>( Callable )).start();
new Thread().start(); // 怎么启动Callable
MyThread thread = new MyThread();
FutureTask futureTask = new FutureTask(thread); // 适配类
new Thread(futureTask,"A").start();
new Thread(futureTask,"B").start(); // 结果会被缓存，效率高
Integer o = (Integer) futureTask.get(); //这个get 方法可能会产生阻塞！把他放到
最后
// 或者使用异步通信来处理！
System.out.println(o);
}
}
class MyThread implements Callable<Integer> {
@Override
public Integer call() {
System.out.println("call()"); // 会打印几个call
// 耗时的操作
return 1024;
}}

1、有缓存 2、结果可能需要等待，会阻塞！

常用的辅助类(必会)

CountDownLatch

public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
// 总数是6，必须要执行任务的时候，再使用！
CountDownLatch countDownLatch = new CountDownLatch(6);
for (int i = 1; i <=6 ; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" Go out");
countDownLatch.countDown(); // 数量-1
},String.valueOf(i)).start();
}
countDownLatch.await(); // 等待计数器归零，然后再向下执行
System.out.println("Close Door");
}
}

countDownLatch.countDown(); // 数量-1

countDownLatch.await();

// 等待计数器归零，然后再向下执行每次有线程调用 countDown() 数量-1，假设计数器变为0，countDownLatch.await() 就会被唤醒，继续执行！

CyclicBarrier

加法计数器

Semaphore

信号量

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

public class SemaphoreDemo {
public static void main(String[] args) {
// 线程数量：停车位! 限流！
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <=6 ; i++) {
new Thread(()->{
// acquire() 得到
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(); // release() 释放
}
},String.valueOf(i)).start();
}
}
}

读写锁

/**
* 独占锁（写锁） 一次只能被一个线程占有
* 共享锁（读锁） 多个线程可以同时占有
* ReadWriteLock
* 读-读 可以共存！
* 读-写 不能共存！
* 写-写 不能共存！
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
// 写入
for (int i = 1; i <= 5 ; i++) {
final int temp = i;
new Thread(()->{myCache.put(temp+"",temp+"");
},String.valueOf(i)).start();
}
// 读取
for (int i = 1; i <= 5 ; i++) {
final int temp = i;
new Thread(()->{
myCache.get(temp+"");
},String.valueOf(i)).start();
}
}
}
// 加锁的
class MyCacheLock{
private volatile Map<String,Object> map = new HashMap<>();
// 读写锁： 更加细粒度的控制
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private Lock lock = new ReentrantLock();
// 存，写入的时候，只希望同时只有一个线程写
public void put(String key,Object value){
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"写入OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
// 取，读，所有人都可以读！
public void get(String key){
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"读取"+key);
Object o = map.get(key);
System.out.println(Thread.currentThread().getName()+"读取OK");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}
/**
* 自定义缓存
*/
class MyCache{
private volatile Map<String,Object> map = new HashMap<>();10、阻塞队列
阻塞队列：
// 存，写
public void put(String key,Object value){
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"写入OK");
}
// 取，读
public void get(String key){
System.out.println(Thread.currentThread().getName()+"读取"+key);
Object o = map.get(key);
System.out.println(Thread.currentThread().getName()+"读取OK");
}
}