JUC学习笔记（一）——lock和synchronized

什么是JUC

java.util下的这三个包

线程和进程

进程：一个程序
一个进程往往可以包含多个线程，至少包含一个！
java默认有几个线程？2个，main，GC
对于java而言：Thread，Runnable， Callable
java真的可以开启一个线程么？
看下源码：


通多调用本地方法，低层c++，java无法直接操作硬件

并发，并行

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

• CPU一核，模拟出多条线程

并行（多个人一起行走）

• CPU多核，多个线程可以同时执行；线程池

public static void main(String[] args) {
        //获取CPU的核数
        //CPU 密集型， IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());
    }

并发编程的本质：充分利用cpu的资源

线程有几个状态：6个

• NEW 新生
• RUNNABLE 运行
• BLOCKED 阻塞
• WAITTING 等待
• TIMED_WAITING 超时等待
• TERMINATED 终止

wait和sleep的区别

• 1.来自不同的类：wait来自Object类，所有类都有，sleep来自thread类
  企业中一般使用

TimeUnit.MILLISECONDS.sleep(100);

其来自于java.util.concurrent.TimeUnit;

• 2. 关于锁的释放：wait会释放锁，sleep会抱着锁睡觉，不会释放
• 3. 使用范围不同：wait必须在同步代码块中使用，sleep可以在任何地方使用
• 4. 是否需要捕获异常：wait不需要捕获异常，sleep需要补货异常

Lock锁（重点）

传统synchronized



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

Synchronized和lock的区别

• 1. Synchronized java内置的关键字，Lock是一个借口
• 2. Synchronized 无法判断锁的状态，Lock可以判断是否获取到了锁
• 3. Synchronized 会自动释放锁，lock需手动释放
• 4. Synchronized线程1（获得锁，阻塞）线程2（等待，傻傻的等），lock锁就不会一直等下去
• 5. Synchronized 可重入锁，不可以终端的，非公平；Lock可重入锁，可以判断锁，非公平（可以自己设置）
• 6. Synchronized 适合少量的代码同步问题，lock适合锁大量的同步代码

生产者和消费者问题

class Data{
    private int number;;

    public synchronized void increment() throws InterruptedException {
        if(number != 0){
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName() + "--->" + number);
        this.notifyAll();
    }

    public synchronized void decrement() throws InterruptedException {
        if(number == 0){
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName() + "--->" + number);
        this.notifyAll();
    }
}

上面代码问题存在，当有两个以上线程时可能会出现2之类的结果，其原因为虚假唤醒

解决方案，将if改为while

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

synchronized中使用wait和notify那lock中有没有配套的来使用呢？

• condition对象中的await()

• condition对象中的signal()

  

使用方法

新代码实现：

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

condition还具有精准的通知和唤醒线程的功能
上面代码执行结果顺序是随机的即有可能ABCD,ABAB这种，我们想要得到制定的顺序即ABCDABCD即唤醒制定的线程该如何操作？看下面代码：

public class Test2 {
    public static void main(String[] args) {
        Data data = new Data();
        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 Data{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    void printA(){
        lock.lock();
        try{
            while (number != 0){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "==>AAAAAAA");
            number = 1;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    void printB(){
        lock.lock();
        try{
            while (number != 1){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "==>BBBBBB");
            number = 2;
            condition3.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    void printC(){
        lock.lock();
        try{
            while (number != 2){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "==>CCCCCC");
            number = 0;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

锁现象

如何判断锁是谁，永远的指导什么锁，锁的对象是谁！

• new this：具体的对象，锁的是方法的调用者即对象
• static class：锁的是class类
  注意是否是同一把锁

集合类不安全

如List，set，hashmap等，比如多线程add元素时会报出ConcurrentModificationException，其原因是这些类为非线程安全的，其中hashset低层为hashmap。
解决方案：

• Collections.synchronized***(new ArrayList);
• CopyOnWriteArrayList,CopyOnWriteArraySet,ConcurrentHashMap

callable

如何像new Thread（Runable）的使用callable？
runnable有个接口，RunableFuture，其有个实现类，FutureTask

具体使用

public class Test2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
       FutureTask<String> futureTask = new FutureTask<>(() ->{
            System.out.println("call()");
            return "callable0";
        });
       new Thread(futureTask).start();
       String result =  futureTask.get();
       System.out.println(result);
    }
}

其中get()方法可能会产生阻塞，把它放在最后，一般会使用一部通信