JUC并发编程 常用锁 三个辅助类的使用

JUC并发编程就是多线程的进阶版，所以很多多线程没写到的会在这里写到

并发和并行的区别

并发：不同的代码块交替执行
比如你跑步跑到一半，来个了电话，你接完电话继续跑步就是并发
.
并行：不同的代码块同时执行
比如你跑步跑到一半，来了个电话，你一边打电话一边跑步就是并行
.
二者区别就是一个是间隔时间处理，一个是同时处理。
当然了如果你跑到一半来电话，你跑完了再接那就是并发并行都不支持

Lock锁

公平锁和非公平锁

公平锁遵循先来后到，先来的先执行
非公平锁遵循先到先得，根据cpu调度时间来运行
默认是非公平锁，因为这样更有效率

Lock锁使用复习

public class demo1 {

    public static void main(String[] args) {
        Ticket a= new Ticket();
        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                a.sale();
            }
        },"A").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                a.sale();
            }
        },"B").start();

        new Thread(()->{
            for (int i = 0; i < 30; i++) {
                a.sale();
            }
        },"C").start();


    }

}
class Ticket{

    private int ticketNum = 30;

    //1.new一个锁
    Lock lock = new ReentrantLock();

    public void sale(){

        //2.在需要锁的代码块加锁
        lock.lock();

        try {
            //3.把代码代码放入try
            if (ticketNum>0){
                System.out.println("卖了第"+(ticketNum--)+"张票,还剩"+ticketNum+"张");
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //4.解锁
            lock.unlock();
        }
    }
}

synchronized锁和lock锁区别

1.syn是java的一个关键字，而lock是java的一个类
.
2.syn无法判断锁的状态，lock可以判断是否获得了锁
.
3.syn会自动释放锁，lock需要手动释放锁(lock.unlock)，不然会造成死锁
.
4.当线程1使用了syn时，线程2会进入等待直到线程1释放，如果这时线程1阻塞，线程2会一直等待
当线程1使用的是lock锁，进入阻塞时，线程2并不一定会等待(lock.tryLock())
.
5.syn 可重入锁，不可以中断，非公平锁
lock锁 可重入锁，可以判断锁，可以手动设置公平或非公平锁
.
6.syn适用于解决小部分代码同步问题
lock锁适用于解决大部分代码同步问题

防止虚假唤醒的方法

其实很简单，就是判断时要用while而不是if

condition

condition实现生产者消费者

public class demo1 {

    public static void main(String[] args) {
        Data data = new Data();

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

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

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

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


class Data {

    private int number = 1;

    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    
    //+1
    public void increment() {

        lock.lock();
        try {
            while (number != 0) {
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程我+1完毕了
            condition.signalAll();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    //-1
    public void decrement() {
        lock.lock();
        try {
            while (number == 0) {
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName() + "=>" + number);
            //通知其他线程我-1完毕了
            condition.signalAll();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

condition实现指定唤醒

//a执行完调用b，再调用c
public class demo2 {
    public static void main(String[] args) {

        Data2 data= new Data2();

        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 Data2{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1;

    public void printA(){
        lock.lock();
        try {
            while (number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"---AAAAAAAAA");
            //唤醒，唤醒指定的人
            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");
            //唤醒，唤醒指定的人
            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()+"---CCCCCCCCC");
            //唤醒，唤醒指定的人
            number = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

Callable的简单调用

public class CallableTese {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread m = new MyThread();

        FutureTask futureTask = new FutureTask(m);

        new Thread(futureTask).start();

        //获取返回值
        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 1111;
    }
}

常用的三个辅助类

CountDownLatch（减法计数器）

两个方法
countDownLatch.countDown(); 数量减一
countDownLatch.await(); 等待计数器归零再执行下面的步骤

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 走了");
                countDownLatch.countDown();//-1
            },String.valueOf(i)).start();
        }
        //等待计数器归零再执行下面的步骤
        countDownLatch.await();
        System.out.println("大家都走了");
    }
}

CyclicBarrier (加法计数器)

等待计时结束 cyclicBarrier.await();

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

        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
            System.out.println("计数达到5，计数成功");
        });

        for (int i = 1; i <= 5; i++) {
            final int a = i;
            new Thread(()->{
                System.out.println("现在计数到第"+a+"个");
                try {
                    //等待计时结束
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

Semaphore(信号量，用于限流)

得到 semaphore.acquire();
释放 semaphore.release();

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

        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {

                try {
                    //得到
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "已进入");
                    TimeUnit.SECONDS.sleep(3);
                    System.out.println(Thread.currentThread().getName() + "已离开");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}

ReadWriteLock

写锁(独占锁) 读锁(共享锁) 的简单使用

写锁(独占锁) 一次只能被一个线程占有
读锁(共享锁) 多个线程可以同时占有
更加细粒度的控制

class MyReadWriteLock{
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    public  void put(){
    
        readWriteLock.writeLock().lock();
        try {
       //代码
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }

    }

    public  void get(){
        readWriteLock.readLock().lock();
        try {
            //代码
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

线程阻塞(BlockingQueue)

四种使用方法