java中Thread的深入了解（三）

1.volatile

可以强制去掉缓存区 每次都去从内存读值

    static byte value=0;
    static boolean finish=false;
    public static void testVolatile() throws InterruptedException {
        value=0;
        finish=false;

        new Thread(new Runnable() {
            @Override
            public void run() {
                while(value==0&&!finish);
                console.info

                        ("value is "+value+" finish is "+finish);

            }
        }).start();
        Thread.sleep(1000);
        new Thread(new Runnable() {
            @Override
            public void run() {
                value=10;
                finish=true;
                console.info

                        ("has set the finish");
            }
        }).start();
    }

可以看到运行结果如图：第一个线程并没有如期结束，在线程循环里， 如果没有与其他线程产生交互 ，他不会读取内存的值 会始终使用缓存的值，所以第一个线程的死循环。

结果

这是因为cpu和线程有个缓存区,当线程运行的时候 读入需要的变量进入缓冲区

线程运行

所以我们可以通过volatile关键字 保证每次读取都会从实际内存里读取

volatile字段添加位置

2.concurrent的BlockingQueue

java 1.6之后有的这个接口，这个是一个线程安全的对象，用于线程之间的通信。
BlockingQueue是一个线程安全的队列接口 ，提供了 put take poll等方法
实现类有 ArrayBlockingQueue LinkedBlockingQueue PriorityBlockingQueue。

• ArrayBlockingQueue初始化的时候要指定大小，且容量就是初始化指定的
• LinkedBlockingQueue 是链表实现 不需要指定大小 会自动扩容
• PriorityBlockingQueue 是一个有优先级的队列，可以让优先级高的先处理，优先级低的后处理

生产者 消费者 用这个就很好解决，如图：

生产者和消费者

BlockingQueue中线程运行

2.1LinkedBlockingQueue

public static void blockingQueueTest(){
        BlockingQueue blockingDeque=new LinkedBlockingQueue();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    console.info

                            (blockingDeque.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"消费者").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    blockingDeque.put("new Msg");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"生产者").start();
    }

2.2PriorityBlockingQueue （优先级）

 public static class Message implements Comparable{

        public  String name;
        public int value=0;

        public Message(int value,String name) {
            this.value = value;
            this.name=name;
        }

        @Override
        public int compareTo(Message o) {
            return value-o.value;
        }
    }

    public static void blockingQueueTests(){
        PriorityBlockingQueue blockingDeque=new PriorityBlockingQueue ();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<100;i++) {
                    try {
                        console.info

                                (blockingDeque.take().name);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        },"消费者").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                blockingDeque.put(new Message(100,"zhangsan"));
                blockingDeque.put(new Message(0,"lisi"));
                blockingDeque.put(new Message(0,"wangwu"));
                blockingDeque.put(new Message(100,"zhaosi"));
            }
        },"生产者").start();
    }

可以看put方法是阻塞的 直到里面有足够的空间存储，take也是阻塞的直到有内容的时候返回，所以上面的线程 即是是消费者直接运行 生产者后运行 也能正确的指向。

3.concurren包的线程池

Executors.newScheduledThreadPool 创建固定大小的线程池
Executors.newFixedThreadPool 创建固定大小的线程池
Executors.newCachedThreadPool 创建缓存线程池 从0 开始 每个线程存货一分钟
Executors.newSingleThreadExecutor 创建只有一个线程的线程池

实际上都是创建了一个ThreadPoolExecutor 控制了不同参数

/**
  *
  *  corePoolSize 线程池最小保持线程数 即是他们处于空闲状态
  *  maximumPoolSize 线程池最大线程数
  *  keepAliveTime 如果线程数超出最小保持 那么线程最大空闲存活实际
  *  unit 存活时间单位单位
  *  初始工作的缓冲区
  */
 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue) {
                              }

eg:

 public static void CountDownLatchTest() throws InterruptedException {
        long startTime=System.currentTimeMillis();
        CountDownLatch countDownLatch=new CountDownLatch(65535);
        ScheduledExecutorService service = Executors.newScheduledThreadPool(9000);
        for(int i=0;i<65535;i++){
            service.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(200);
                        countDownLatch.countDown();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        try {
            countDownLatch.await();
            service.shutdown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("所有线程完成了!"+(System.currentTimeMillis()-startTime)+"ms");
    }

4.ReentrantReadWriteLock

synchronized 获取锁的方式 是不区分读写的，只要获取锁就排斥其他所有线程
ReentrantReadWriteLock 把锁分成读锁和写锁：读锁不排斥读锁 也就是多个线程都可以进入读锁。
写锁 排斥读锁和其它写锁，换成写锁的话只有一个线程能获取到锁。
锁用完需要进行释放unlock()

  public static void ReadWriteLock(){
        ReadWriteLock reentrantLock=new ReentrantReadWriteLock();
        Lock readLock=reentrantLock.readLock();
        Lock writeLock=reentrantLock.writeLock();
        for(int i=0;i<2;i++)
            new Thread(new Runnable() {
                @Override
                public void run() {
                    readLock.lock();
                    console.info

                            ("获取到了读锁1");
                    try {
                        Thread.sleep(20);
                        readLock.unlock();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        for(int i=0;i<2;i++)
        new Thread(new Runnable() {
            @Override
            public void run() {
                writeLock.lock();
                console.info

                        ("获取到了写锁2");
                try {
                    Thread.sleep(2000);
                    writeLock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }

会发现不是立马两个线程都运行了，是先运行了第一个，等待线程运行完成，在运行第二个。

运行结果