多线程-进阶

并发并行

并发：多个线程操作同一个资源

并行：多个线程可以同时执行（CPU必须是多核的）

并发编程的实质：充分利用CPU的资源（公司比较看重）

//获取CPU的核数
System.out.println(Runtime.getRuntime().availableProcessors());

线程的6种状态

1、New(初始)：线程新生

2、Runnable：运行状态

3、Blocked：阻塞

4、Waiting：等待，是一种阻塞

5、Time_waiting：超时等待

6、Terminated：终止

wait和sleep的区别

1. 来自不同的类

wait->Object

sleep->Thread

2. 关于锁的释放

wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放

3. 使用的范围是不同的

wait必须在同步代码块红，sleep哪里都可以

lock锁

if会存在虚假唤醒问题

public class Test3 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.addNumber();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }, "A").start();

        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.deNumber();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.deNumber();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.deNumber();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }, "D").start();

    }


}
//判断等待-业务计算-通知
class Data {
    private int num=0;
    public synchronized void addNumber() throws InterruptedException {
        while(num!=0){//防止虚假唤醒
        this.wait();//等待
        }
        num++;
        System.out.println(Thread.currentThread().getName()+"->"+num);
        this.notifyAll();//通知

    }
    public synchronized void deNumber() throws InterruptedException {
        while(num==0){
            this.wait();//等待
        }
        num--;
        System.out.println(Thread.currentThread().getName()+"->"+num);
        this.notifyAll();//通知
    }
}

传统：1.synchronized ，2.wait等待,3.notifyAll唤醒全部

现在：1.lock ，condition（2.await等待，3.signalAll唤醒全部）

condition可以实现精准通知唤醒

condition.await();

condition2.sigal();

8锁现象

集合类不安全

ArrayList在单线程时安全，在并发时不安全

//  List<String> list=new Vector<>();
  List<String> list=new ArrayList<>();
  List<String> list1= Collections.synchronizedList(new ArrayList<>());//可以变安全
  List<String> list2= new CopyOnWriteArrayList<>();//并发时安全，写入时复制，DOW计算机程序设计的一种优化策略，比vector（有synlized效率都低）效率高

set不安全：

// Set<String> set = new HashSet<>();
 Set<String> set1 = Collections.synchronizedSet(new HashSet<>());
 Set<String> set = new CopyOnWriteArraySet();//和list一样

Map不安全

Map<String, String> map = new HashMap();//加载因子（0.75），初始容量（16）
Map<String, String> map1 = Collections.synchronizedMap(new HashMap<>());
Map<String, String> map2 =new ConcurrentHashMap<>();//并发的hashmap这个和ArrayList，HashSet不一样

callable

1. 与另两个相比，可以有返回值；
2. 可以抛出异常；
3. 方法不同，run和call。

MyThread myThread=new MyThread();
//适配类
FutureTask futureTask=new FutureTask(myThread);//FutureTask是个中间商，可以吧Callable和Runnable连接起来
new Thread(futureTask,"A").start();
Integer o= (Integer) futureTask.get();//获取Callable的返回值
/*
*new Thread(futureTask,"A").start();
*new Thread(futureTask,"B").start();//会打印一个call，结果会被缓存，提高效率，
*1.有缓存
*2.结果需要等待
*/

常用的辅助类

1. CountDownLatch
数量减一，计数器归零，await等待结束，会被唤醒
 countDownLatch.countDown();//数量减一
  countDownLatch.await();//等待计数器归零，计数器变为0，await结束等待
2. CyclicBarrier
 cyclicBarrier.await();//会进行计数，数量+1，计数后会开启新的线程执行
3.Semaphore//适用于停车位，限流
 Semaphore semaphore=new Semaphore(6);//默认线程数量
                    semaphore.acquire();//得到资源，如果已经满了，需要等待
                    TimeUnit.SECONDS.sleep(2);
                    semaphore.release();//释放资源，当前的信号释放量+1，唤醒等待的资源
                

读写锁

ReadWriteLock readWriteLock= new ReentrantReadWriteLock();
readWriteLock.writeLock().lock();
readWriteLock.writeLock().unlock();