java_thread

多线程学习

1.countDownLatch

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

class CountDownLatchTest {
public static void main(String [] args){
    CountDownLatch count = new CountDownLatch(1);
    for(int i=1; i<4; i++){
        new Thread(new CountDownThread(count,i*1000)).start();
    }
    new Thread(new AwaitThread(count)).start();
    new Thread(new AwaitThread(count)).start();
}



//运行线程， 执行countDown()操作
static class CountDownThread implements Runnable{
    CountDownLatch count;
    private long sleepTime;
    public CountDownThread(CountDownLatch count,long sleepTime){
        this.count = count;
        this.sleepTime = sleepTime;
    }
    public void run(){
        long startTime=System.currentTimeMillis();
        System.out.println("CountDownThread : "+this.toString() + " runing ...");
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        count.countDown();
        System.out.println("CountDownThread : "+this.toString()+" finished ..."+(System.currentTimeMillis()-startTime));
    }
}
//等待线程
static class AwaitThread implements Runnable{
    CountDownLatch count;
    public AwaitThread(CountDownLatch count){
        this.count = count;
    }
    public void run(){
        long startTime=System.currentTimeMillis();
        System.out.println("AwaitThread : "+this.toString()+" await ...");
        try {
            this.count.await(10, TimeUnit.SECONDS);//等待两秒钟， 如果CountDownLatch没有countDown到0，自动唤醒，否则立即唤醒
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("AwaitThread : "+this.toString()+"finished ...  "+(System.currentTimeMillis()-startTime));
    }
}

使用场景，n多线程某一步执行需要一个线程作为ready,这时可以使用CoundDownLatch
比如上面，AwaitThread本来要睡眠10S的，但是实际上在有一CountDownThread执行完后就被自动唤醒，基本
性质如下：

• 1. 减数线程不会停留
• 1. 可以唤起多个线程

2.CyclicBarrier

class TestCyclicBarrier {

    private static final int THREAD_NUM = 5;

    public static class WorkerThread implements Runnable{

        CyclicBarrier barrier;
        String name;
        int count;
        public WorkerThread(CyclicBarrier b, String n, int i){
            this.barrier = b;
            this.name = n;
            this.count = i;
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            try{
                if(this.count<=2){
                    System.out.println(this.name+" sleep...");
                    Thread.sleep(10000);
                }
                System.out.println(this.name + " Worker's waiting");
                //线程在这里等待，直到所有线程都到达barrier。
                barrier.await();
                System.out.println(this.name + " ID:"+Thread.currentThread().getId()+" Working");
            }catch(Exception e){
                e.printStackTrace();
            }
        }

    }

        /**
         * @param args
         * @throws InterruptedException
         */
        public static void main(String[] args) throws InterruptedException {
            // TODO Auto-generated method stub
            CyclicBarrier cb = new CyclicBarrier(THREAD_NUM, new Runnable() {
                //当所有线程到达barrier时执行
                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    System.out.println("\nInside Barrier\n");

                }
            });

            for(int i=0;i<THREAD_NUM;i++){
                new Thread(new WorkerThread(cb, "before"+i, i)).start();
            }

        }

}

特点如下

1. 执行线程会暂定等待
2. 只能唤起一个ready线程

3.Semaphone

操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，acquire()获取一个许可，如果没有就等待，而release()释放一个许可。
如下有5个竞争者，同时并行只有两个名额

class SemaphoreTest implements Runnable{

    Semaphore sem;
    String name;
    public SemaphoreTest(Semaphore s, String name){
        this.sem = s;
        this.name = name;
    }
    @Override
    public void run() {
        try {
            System.out.println(this.name + " Thread acquire a source");
            sem.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name+ " Thread do something");
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.name+" Thread release");
        sem.release();
    }
    public static void main(String [] args){
        Semaphore sem = new Semaphore(2);
        ExecutorService exc = Executors.newCachedThreadPool();
        for(int i=0; i<5; i++){
            exc.execute(new SemaphoreTest(sem, "name"+i));
        }
        exc.shutdown();
    }

}