java之JUC

java的JUC即java.util.concurrent包，这是一个处理线程的工具包。

一、synchronized与lock锁 两者区别?

1.synchronized是java关键字，lock是一个类；
2.Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁；
3.Synchronized会自动释放锁，而lock需要手动释放锁，否则会造成死锁；
4.Synchronized 线程1（获得锁，阻塞）线程2（等待，傻傻的等），Lock锁不一定会等待下去；
5.Synchronized是可重入锁，非公平不可中断，Lock是可重入锁，非公平（可自定义），可以判断锁（lock.tryLock()）
6.Synchronized适合少量代码同步问题，Lock适合大量的同步代码。

二、wait和sleep的区别？

1.wait在object类中
sleep在Thread类中
2.wait会释放锁
sleep不会释放锁
3.使用范围
wait必须使用在同步代码块中，
sleep可以在任何地方使用。

三、线程的几种状态

新生
运行
阻塞
等待
超时等待
终止

四、condition精准唤起线程

public class A {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for(int i = 0;i<10;i++){
                data3.printA();
            }
        }).start();
        new Thread(()->{
            for(int i = 0;i<10;i++){
                data3.printB();
            }
        }).start();
        new Thread(()->{
            for(int i = 0;i<10;i++){
                data3.printC();
            }
        }).start();
    }


}
class Data3{
    private Lock lock1 = new ReentrantLock();
    Condition condition = lock1.newCondition();
    Condition condition2 = lock1.newCondition();
    Condition condition3 = lock1.newCondition();
    private int num = -1;
    public void printA(){
        lock1.lock();
        try {
            while (num!=-1){
                condition.await();
            }
            num = 0;
            System.out.println(Thread.currentThread().getName()+"AAAAAAAAA");
            condition2.signal();
        }catch (Exception e){

        }finally {
            lock1.unlock();
        }

    }
    public void printB(){
        lock1.lock();
        try{
            while (num!=0){
                condition2.await();
            }
            num = 1;
            System.out.println(Thread.currentThread().getName()+"BBBBBBBBB");
            condition3.signal();
        }catch (Exception e){

        }finally {
            lock1.unlock();
        }
    }
    public void printC(){
        lock1.lock();
        try{
            while (num!=1){
                condition3.await();
            }
            num = -1;
            System.out.println(Thread.currentThread().getName()+"CCCCCCCCCCC");
            condition.signal();
        }catch (Exception e){

        }finally {
            lock1.unlock();
        }
    }
}

五.callable与runnable方法的区别：

1.callable有返回值；
2.callable可以抛出异常；
3.方法不同，run()/call()

public class CallableTest {
    public static void main(String[] args) throws Exception{
        MyCallable myCallable = new MyCallable();
        FutureTask futureTask = new FutureTask(myCallable);
        new Thread(futureTask,"threadA").start();
        Integer i = (Integer) futureTask.get();//get方法可能会产生阻塞，把该方法放到最后执行 或者使用异步方法来执行
        System.out.println(i);
    }
}
class MyCallable implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("call方法执行！！！");
        return 100;
    }
}

六、常用的辅助类

1.countdownLaunch（减法计数器）
countdownLaunch.countDown(); //数量-1
countdownLaunch.await();//等待计数器归零，然后再向下执行
2.cyclicBarrier（加法计数器）
3.semaphore
Semaphore.acquire()获得，如果已经满了，等待，等待被释放为止
Semaphore.release()释放，会将当前的信号量释放+1，然后唤醒等待线程
作用：多个共享资源互斥的使用，并发限流，控制最大的线程数。

public class CountdownlaunchTest {
    public static void main(String[] args)throws Exception {
        //总数是6
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for(int i = 0;i<6;i++){
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"go");
                countDownLatch.countDown(); //数量-1
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println("---------------------");
    }
}

public class CyclicBarrierTest {
    public static void main(String[] args)throws Exception {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("第7个线程");
        });
        for(int i = 0;i<7;i++){
            int s = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"go");
                try{
                    System.out.println(s);
                    cyclicBarrier.await();
                }catch (Exception e){

                }
            },String.valueOf(i)).start();
        }
    }
}

public class SeamphoreTest {
    public static void main(String[] args) throws Exception{
        Semaphore semaphore = new Semaphore(3);
        for(int i = 0;i<6;i++){
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"获得停车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开停车位");
                }catch (Exception e){

                }finally {
                    semaphore.release();
                }

            },String.valueOf(i)).start();
        }
    }
}

七、线程池

线程池：7大参数、4种拒绝策略

自定义线程池：

public class ExecutorsTest {
    public static void main(String[] args) {
        BlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(3);
        RejectedExecutionHandler abortPolicy = new ThreadPoolExecutor.AbortPolicy();
        ThreadPoolExecutor.DiscardPolicy discardPolicy = new ThreadPoolExecutor.DiscardPolicy();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(3,5,
                2L, TimeUnit.SECONDS, blockingQueue,Executors.defaultThreadFactory(),discardPolicy);
        for (int i = 0;i<9;i++){
            final int n = i;
            threadPoolExecutor.execute(()->{
                System.out.println(Thread.currentThread().getName()+"执行任务");
            });
        }
        threadPoolExecutor.shutdown();
    }
}

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) 

 四种线程池：newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor、newScheduleThreadPool