8-并发包

package ConcurrentHashMap;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class CHMDemo1 {

    //public static Map<String,String> maps=new HashMap<>();
    //public static Map<String,String> maps=new Hashtable<>();
    public static Map<String,String> maps=new ConcurrentHashMap<>();

    public static void main(String[] args) {
        Runnable target = new CHMRunnable();
        Thread t1 = new Thread(target);
        Thread t2 = new Thread(target);
        t1.start();
        t2.start();


        /*
        * 注意：首先这里不可以直接简化用new Thread(target).start();开启线程
        * 两个线程必须实例化对象，这是由于后续要用到join()方法
        * join方法的作用在于避免主线程和t1,t2两个线程争抢CPU
        * 使用join方法后，在t1,t2执行完之前，后续主线程都不会执行
        * 这就避免了提前打出maps长度导致结果并不是最终运行的结果
        * 同时t1,t2都用到了join方法，所以二者之间仍然是并发执行
        * */
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("maps长度="+maps.size());
        /*
        * 可以看到，当使用hashmap类型时，最终的执行结果并不是1000000
        * 这是由于单纯通过hashmap算法可能出现两个线程同时插入到同一线程的情况
        * HashMap时线程不安全的，性能好
        *
        * 可以看到，当使用hashtable类型时，最终执行结果始终都是1000000
        * 可见hashtable保证了线程的安全性，但是这种方式效率极低，在项目中基本被舍弃
        * 因为它的实现方式在每个方法中都加上了锁
        * HashTable时线程安全的，性能较差
        *
        * ConcurrentHashMap的实现与hashtable不同，它只锁住对应变量的桶（分段式锁）
        * 所以其他变量的增删改不会相互影响，效率得到了极大的保证
        * 保证了线程安全，综合性能较好
        * */
    }
}


class CHMRunnable implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<500000;i++){
            CHMDemo1.maps.put(Thread.currentThread().getName()+i,Thread.currentThread().getName()+i);
        }
    }
}

package ConcurrentHashMap;

//CountDownLatch

import java.util.concurrent.CountDownLatch;

public class CDLDemo {
    public static void main(String[] args) {
        //创建CountDownLatch对象，用于监督1，2线程的执行情况
        //这里传入的参数是步数，表示唤醒线程需要的步数，部署为0时，等待的线程开始执行
        //这种方法比线程通信更加灵活
        CountDownLatch c=new CountDownLatch(1);
        new Thread_first(c).start();
        new Thread_second(c).start();
    }
}

class Thread_first extends Thread{
    private CountDownLatch c;
    public Thread_first(CountDownLatch c) {
        this.c=c;

    }

    @Override
    public void run() {
        System.out.println("A");
        //等待状态,让当前线程让出CPU等待
        try {
            c.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("C");
    }
}

class Thread_second extends Thread{
    private CountDownLatch c;
    public Thread_second(CountDownLatch c) {
        this.c=c;

    }

    @Override
    public void run() {
        System.out.println("B");
        c.countDown();  //让计数器减一,当计数器为0时唤醒等待的线程
    }
}

package ConcurrentHashMap;

//CyclicBarrier

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CBDemo {
    public static void main(String[] args) {
        //创建任务循环屏障对象,等到5个线程全部执行完毕之后触发一次任务
        // 第一个参数表示等待线程执行的个数，第二个参数表示执行的任务
        CyclicBarrier c=new CyclicBarrier(5,new CBRunnable());
        for (int i = 0; i < 5; i++) {
            new CBThread("用户"+i,c).start();
        }

    }
}

class CBRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("五个任务全部执行完毕，"+Thread.currentThread().getName()+"开始执行！");
    }
}

class CBThread extends Thread{
    private CyclicBarrier c;
    public CBThread(String s,CyclicBarrier c) {
        super(s);
        this.c=c;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName()+"正在执行！");
            c.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

用户3正在执行！
用户1正在执行！
用户2正在执行！
用户0正在执行！
用户4正在执行！
五个任务全部执行完毕，用户3开始执行！

用户4正在执行！
用户6正在执行！
用户1正在执行！
用户5正在执行！
用户3正在执行！
用户2正在执行！
用户8正在执行！
用户7正在执行！
用户0正在执行！
用户9正在执行！
五个任务全部执行完毕，用户7开始执行！
五个任务全部执行完毕，用户9开始执行！

package ConcurrentHashMap;

import java.util.concurrent.Semaphore;

public class SemaphoreDemo {
    public static void main(String[] args) {
        SemaTask task=new SemaTask();
        for (int i = 0; i < 10; i++) {
            new SemaThread(task).start();
        }

    }
}


//任务代码
class SemaTask{
    //创建Semaphore对象，第一个参数表示允许执行acquire和release之间内容的线程数量
    private Semaphore sema=new Semaphore(2);
    public void task(){
        try {
            sema.acquire();
            System.out.println(Thread.currentThread().getName()+"进入时间："+System.currentTimeMillis());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"离开时间："+System.currentTimeMillis());
            sema.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class SemaThread extends Thread{
    private SemaTask task;
    public SemaThread(SemaTask task){
        this.task=task;
    }
    @Override
    public void run() {
        task.task();
    }
}

package ConcurrentHashMap;

import java.util.concurrent.Exchanger;

public class ExchangerDemo {
    public static void main(String[] args) {
        //创建Exchanger交换数据
        Exchanger<String> exch=new Exchanger<String>();
        Thread t1=new task("task1",exch,"你好，我是task1");
        Thread t2=new task("task2",exch,"你好，我是task2");
        t1.start();
        t2.start();
    }
}

class task extends Thread{
    private Exchanger<String> exch;
    private String result;
    public task(String name,Exchanger exch,String result){
        super(name);
        this.exch=exch;
        this.result=result;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"正在执行工作流程");
        //交换结果
        try {
            String s=exch.exchange(result);
            System.out.println(Thread.currentThread().getName()+"收到交换信息“"+s+"”");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

task2正在执行工作流程
task1正在执行工作流程
task2收到交换信息“你好，我是task1”
task1收到交换信息“你好，我是task2”