并发编程-线程之间通信

柔情只为你懂 2022-02-22 03:28 314阅读 0赞

### 多个线程在操作同一个资源 ###

###    synchronized ###

wait、notify（**一定要在线程同步中使用,并且****是同一个锁的资源。wait释放锁，notify不释放锁**）

public void runBase(){
            Object lock = new Object();
            new Thread(){
                public void run(){
                    synchronized (lock){
                        try {
                            lock.wait();
                            sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                 }
            }.start();
            new Thread(){
                public void run(){
                    synchronized (lock){
                        lock.notify();
                    }
                }
            }.start();
        }

### lock（Condition） ###

public void run02(){
            Lock lock = new ReentrantLock();
            Condition condition = lock.newCondition();
            new Thread(){
                public void run(){
                    try {
                        lock.lock();
                        condition.await();
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }
            }.start();
            new Thread(){
                public void run(){
                    try {
                        lock.lock();
                        condition.signal();
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }
            }.start();
        }

### CountDownLatch ###

有一个任务A，它要等待其他4个任务执行完毕之后才能执行

public static void main(String[] args) {
            CountDownLatch countDownLatch = new CountDownLatch(4);
            new Thread(new Runnable() {
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ",子线程开始执行...");
                    try {
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ",子线程结束执行...");
                }
            }).start();
            for(int i = 0;i<10;i++){
                new Thread(new Runnable() {
                    public void run() {
                        try {
                            Thread.sleep(500);
                            System.out.println("开始执行:" + Thread.currentThread().getName());
                            countDownLatch.countDown();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        }

### Volatile（volatile 的读性能消耗与普通变量几乎相同，但是写操作稍慢） ###

1.保证此变量对所有的线程的可见性

2.禁止指令重排序优化。（赋值后多执行了一个“load addl $0x0, (%esp)”操作，这个操作相当于一个内存屏障（指令重排序时不能把后面的指令重排序到内存屏障之前的位置））

3.并不能保证原子性。（还是不安全的）

### 原子类（Atomic ，比较再交换） ###

是一种乐观锁

AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference等

public void atomicRun(){
            AtomicBoolean atomicBoolean = new AtomicBoolean(true);
            if(atomicBoolean.compareAndSet(true,false)){
                System.out.println("true就执行，并同时把值改为false");
            }
        }

### CyclicBarrier（大家准备好，一起跑。） ###

public static void main(String[] args) {
            CyclicBarrier cyclicBarrier=new CyclicBarrier(5);
            for (int i = 0; i < 5; i++) {
                new Thread(new Runnable() {
                    public void run() {
                        try {
                            System.out.println("等待执行:" + Thread.currentThread().getName());
                            cyclicBarrier.await();
                            System.out.println("开始执行:" + Thread.currentThread().getName());
                        } catch (InterruptedException | BrokenBarrierException e) {
                            e.printStackTrace();
                        }
                    }
                }).start();
            }
        }

### Semaphore（设置茅坑数量，无论多少人，都得竞争这几个茅坑） ###

public static void main(String[] args) {
            Semaphore semp = new Semaphore(5);
            for (int i = 0; i < 50; i++) {
                new Thread(new Runnable() {
                    public void run() {
                        try {
                            System.out.println("排队上厕所:" + Thread.currentThread().getName());
                            semp.acquire();//申请资源
                            System.out.println("当前厕所剩余数:" + semp.availablePermits());
                            Thread.sleep(500);
                            System.out.println("厕所上完了:" + Thread.currentThread().getName());
                        }catch (InterruptedException e) {
                            e.printStackTrace();
                        }finally {
                            semp.release();//释放资源
                        }
                    }
                }).start();
            }
        }