第11章 进程与多线程

/*****************
***第11章 进程与多线程
*******知识点:
**************1.进程和线程的概念与原理
******************1.1 进程
******************1.2 线程
**************2.线程的创建和启动
******************2.1 定义线程
******************2.2 实例化线程
******************2.3 应用
**************3.线程栈模型与线程的变量
**************4.状态转换
******************4.1 五大状态
******************4.2 生命周期
******************4.3 状态关键字
**************5.同步和锁
******************5.1 同步方法
******************5.2 同步块
******************5.3 生产者消费者模型
******************5.4 死锁
******************5.5 volatile关键字
**************6.交互
******************6.1 交互关键字
**************7.调度
******************7.1 休眠
******************7.2 优先级
******************7.3 让步
******************7.4 合并
******************7.5 守护线程
**************8.新特征
******************8.1 线程池
******************8.2 有返回值的线程
******************8.3 锁调度
******************8.4 信号量
******************8.5 阻塞队列
******************8.6 阻塞栈
******************8.7 条件变量
******************8.8 原子量
******************8.9 障碍器
*/

import java.util.*;
import java.util.concurrent.*;  //新特性包

/*
*继承Thread 演示线程类
*/
class MyThreadTest1 extends Thread{
    private String name;
    public MyThreadTest1(){
        super("无名氏");
        this.name = "无名氏";    
    }
    public MyThreadTest1(String name){
        super(name);
        this.name = name;
        
    }
    public void run(){
        for(int i = 0 ; i < 10; i++){
            System.out.println("线程类：" + this.getClass() + "——线程对象：" + name + "——打印出来：" + i);
            if(i % 3 == 0){
                try{
                    System.out.println("能整除3，我要休息一下！");
                    Thread.sleep(1000);//睡眠1000毫秒  即1秒
                }catch(InterruptedException e){
                    System.out.println("线程异常！");
                }
            }
        }
    }
    
}

/*
*实现Runnable接口 演示线程类
*/
class MyThreadTest2 implements Runnable{
    private String name;
    public MyThreadTest2(){
        this.name = "无名氏";
    }
    
    public MyThreadTest2(String name){
        this.name = name;
    }
    
    public void run(){
        for(int i = 0 ; i < 10; i++){
            System.out.println("线程类：" + this.getClass() + "——线程对象：" + name + "——打印出来：" + i);
        }
    }
}

/*
*演示线程池类
*/
class testPool extends Thread{
    public void run(){
        System.out.println(Thread.currentThread().getName() + "正在运行.....");
    }
}

/*
*主任务类
*/
class MainTask implements Runnable{
    public void run(){
        System.out.println("主任务运行.....");
    }
}

/*
*子任务类
*/
class SubTask implements Runnable{
    private String name;
    private CyclicBarrier cb; //主任务障碍器
    
    public SubTask(String name,CyclicBarrier cb){
        this.name = name;
        this.cb = cb;
    }
    
    public void run(){
        System.out.println("子任务" + name + "开始运行.....");
        for(int i = 0; i < 500000; i++){
            
        }
        System.out.println("子任务" + name + "完成运行");
        try{
            cb.await();  //设置障碍器等待状态
        }catch(InterruptedException e){
              e.printStackTrace(); 
        }catch(BrokenBarrierException e){
              e.printStackTrace(); 
        }
    }
        
}

public class test11{
    public static void main(String[] args){
        demoBaseInfo();//演示1.进程和线程的概念与原理
        demoCreateThread();//演示2.线程的创建和启动
        demoThreadStack();//演示3.线程栈模型与线程的变量
        demoThreadState();//演示4.状态转换
        demoSynchronizeAndLock();//演示5.同步和锁
        demoThreadInteraction();//演示6.交互
        demoThreadDispatch();//演示7.调度
        demoThreadNewFeatures();//演示8.新特征
    }
    
    /*
    *1.进程和线程的概念与原理
    */
    public static void demoBaseInfo(){
        /**1.1进程**/
        //进程：一个内存中运行的应用程序，拥有自己独立的一块内存空间，一个进程中可以有多个线程
        
        /**1.2线程**/
        //线程：进程中的一段执行流程。一个进程中的多个线程共享进程中的内存数据(所以可以理解线程是轻量级的进程)
    }
    
    /*
    *2.线程的创建和启动
    */
    public static void demoCreateThread(){
        //两种方式创建进程
        //1.继承Thread类 重写run方法
        //2.实现Runnable接口  重写run方法
        Thread mythread1 = new MyThreadTest1();//通过继承线程类创建实例
        
        Thread mythread2 = new Thread(new MyThreadTest2("ciade"));//通过实现接口创建实例  注意与第一种方式的区别
        
        System.out.println(Thread.currentThread());//Thread.currentThread()返回当前执行的线程对象
        
        mythread1.start();    //只有调用了start()方法后，线程才能从新建状态移动到可运行状态
        mythread2.start(); //只有调用了start()方法后，线程才能从新建状态移动到可运行状态
        
        
    }
    
    /*
    *3.线程栈模型与线程的变量
    */
    public static void demoThreadStack(){
        //单不使用线程时，虚拟机中的调用栈应该是main()->main()的调用的方法1->main()的调用的方法2
        
        //使用线程时,当程序执行到start()方法时，会在原来栈上多出一个分支(可称为栈B 之前的栈为栈A)，两条线并行执行
        
        //理解即可  可配合画图说明
    }
    
    /*
    *4.状态转换
    */
    public static void demoThreadState(){
        /**4.1 五大状态**/
        //1.新建状态：线程对象已经定义声明并初始化，还没调用start()之前
        //2.可运行状态： 调用start()
        //3.运行状态：选择一个线程作为当前运行线程
        //4.等待/阻塞/睡眠状态：线程还是活的，只是没有条件运行而已
        //5.死亡状态：调用run()方法完成后的状态。注意如果在一个死去的线程上调用start()方法会出现异常
        
        /**4.2 生命周期**/
        //新建(new)->可运行(start)->运行(run)->死亡(run结束)
        //(其中运行状态可以变成等待/阻塞/睡眠状态(sleep)，再变成可运行状态 ，如此循环)
        //可配合画图理解
        
        /**4.3 状态关键字**/
        //1.sleep关键字——————强制当前正在执行的线程休眠  
        //    使用方式：Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)
        //    注意事项：
        //            1.线程睡眠是帮助所有线程获得运行机会的最好办法
        //            2.线程睡眠到期自动苏醒，并返回到可运行状态，注意不是运行状态。
        //            3.sleep()中指定的是时间是线程不会运行的最小时间，所以不能保证该线程睡眠到期后就开始运行
        //            4.sleep()是静态方法，只能控制当前正在运行的线程
        //            5.sleep()时有可能出现InterruptedException异常  注意try..catch
        
        //2.yield关键字———————让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会
        //    使用方式：Thread.yield()
        //    注意事项：
        //            1.yield()从未导致线程转到等待/睡眠/阻塞状态
        //            2.在大多数情况下，yield()将导致线程从运行状态转到可运行状态
        //            3.实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中
        //所以这个关键字是然并卵
        
        //3.线程的优先级
        //线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。
        //在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。
        
        //设置优先级————————线程对象调用setPriority(int Priority)方法  其中Priority参数取值范围：1~10
        //获取线程优先级——————线程对象调用getPriority()方法
        //线程类优先级静态常量——————MAX_PRIORITY(最大) 、MIN_PRIORITY(最小)、NORM_PRIORITY(默认为5)
        
        //4.join关键字——————让一个B线程加入到另一个A线程的尾部。即A执行完毕之前，B不能工作.
        //                    线程的加入join()对线程栈导致的结果是线程栈发生了变化，当然这些变化都是瞬时的
        //5.interrupt关键字——————通知该线程中止，当改线程进行到阻塞状态时（sleep等），才会退出线程
        //6.stop关键字——————强行退出线程，有可能导致异常发生，所以不建议使用该方法
        
    }
    
    /*
    *5.同步和锁
    */
    public static void demoSynchronizeAndLock(){
        //同步：是保证多线程安全访问竞争资源的一种手段
        //同步方法：
        /*
        （1）wait() / notify()方法
        （2）await() / signal()方法
        （3）BlockingQueue阻塞队列方法
        （4）PipedInputStream / PipedOutputStream
          第四种暂不说明
        */
        //锁：Java中每个对象都有一个内置锁
        /*
        关于锁和同步，有一下几个要点：
            1）、只能同步方法，而不能同步变量和类；
            2）、每个对象只有一个锁；当提到同步时，应该清楚在什么上同步？也就是说，在哪个对象上同步？
            3）、不必同步类中所有的方法，类可以同时拥有同步和非同步方法。
            4）、如果两个线程要执行一个类中的synchronized方法，并且两个线程使用相同的实例来调用方法，那么一次只能有一个线程能够执行方法，另一个需要等待，直到锁被释放。
                也就是说：如果一个线程在对象上获得一个锁，就没有任何其他线程可以进入（该对象的）类中的任何一个同步方法。
            5）、如果线程拥有同步和非同步方法，则非同步方法可以被多个线程自由访问而不受锁的限制。
            6）、线程睡眠时，它所持的任何锁都不会释放。
            7）、线程可以获得多个锁。比如，在一个对象的同步方法里面调用另外一个对象的同步方法，则获取了两个对象的同步锁。
            8）、同步损害并发性，应该尽可能缩小同步范围。同步不但可以同步整个方法，还可以同步方法中一部分代码块。
            9）、在使用同步代码块时候，应该指定在哪个对象上同步，也就是说要获取哪个对象的锁。
        */
        
        /*
        线程同步小结
            1、线程同步的目的是为了保护多个线程反问一个资源时对资源的破坏。
            2、线程同步方法是通过锁来实现，每个对象都有切仅有一个锁，这个锁与一个特定的对象关联，线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。
            3、对于静态同步方法，锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。
            4、对于同步，要时刻清醒在哪个对象上同步，这是关键。
            5、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。
            6、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。
            7、死锁是线程间相互等待锁锁造成的，在实际中发生的概率非常的小。真让你写个死锁程序，不一定好使，呵呵。但是，一旦程序发生死锁，程序将死掉。
        */
        
        
    /**5.1 同步方法**/
    /*
    class TicketSource implements Runnable{
    private int ticket = 50;
    public void run(){
        for(int i = 1 ; i < 50; i++){    
                try{
                    Thread.sleep(100);
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                sale();
        }
    }
    
    public synchronized void sale(){  //同步方法
        if(ticket > 0){
            System.out.println(Thread.currentThread().getName()+"号窗口卖出"+this.ticket--+"号票");
        }
    }
    public static void main(String[] args){
        TicketSource  mt = new TicketSource();
        new Thread(mt,"000").start();
        new Thread(mt,"001").start();
        new Thread(mt,"002").start();
    
    
    }*/
    /**5.2 同步块**/
    /*
    class TicketSouce implements Runnable
    {
        //票的总数
        private int ticket=10;
        public void run()
        {
            for(int i=1;i<50;i++)
            {
                synchronized(this){//同步块  注意位置  不能放在if后面
                    if(ticket>0)
                    {
                        //休眠1s秒中，为了使效果更明显，否则可能出不了效果
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"号窗口卖出"+this.ticket--+"号票");
                    }
                                  }
            }
        }
    }
    */
    
    //总结：在使用同步块的时候一定要清楚同步块的位置，因此推荐使用同步方法
    
    /**5.3 生产者消费者模型**/
    /*对于此模型，应该明确一下几点：
    1、生产者仅仅在仓储未满时候生产，仓满则停止生产。
    2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。
    3、当消费者发现仓储没产品可消费时候会通知生产者生产。
    4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。
    */
    
    /*三种实现方式*/
    
    /*1.wait()/notifyAll()方式
    //仓库类
    class Storge{
        private final int MAX_SIZE = 100;
        private LinkedList<Object> list = new LinkedList<Object>();
        
        public int getMAX_SIZE(){
            return MAX_SIZE;
        }
        
        public void setList(LinkedList<Object> list){
            this.list = list;
        }
        
        public LinkedList<Object> getList(){
            return list;
        }
        public Storge(){
            
        }
        
        //生产方法
        public void produce(int num,String name){
            synchronized(list){
                while(list.size() + num > MAX_SIZE ){ //判断会不会满仓溢出
                    System.out.println("要生产的产品数量：" + num + " 库存量：" 
                                        + list.size() + "  " + name +"暂时不能执行生产任务");
                    try{
                        list.wait();//设置阻塞状态
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
                for(int i = 1; i <= num ;i++){
                    list.add(new Object());//生产
                }
                System.out.println(name + "已经生产了产品数量：" + num + " 库存量现在为:" + list.size());
                list.notifyAll();//唤醒其他等待线程
            }
            
        }
        
        //消费方法
        public void  consume(int num,String name){
            synchronized(list){
                while(num > list.size() ){//判断有没可消费的库存
                    System.out.println("要消费的产品数量：" + num + " 库存量：" 
                                        + list.size() + "  " + name +"暂时不能执行消费任务");
                    try{
                        list.wait();//设置阻塞状态
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                        
                }
                for(int i = 1; i <= num ;i++){
                    list.remove();//移除消费项
                }
                System.out.println(name + "已经消费了产品数量：" + num + " 库存量现在为:" + list.size());
                list.notifyAll();//唤醒其他等待线程
            }
            
        }
        
    }

    //生产类
    class Producer extends Thread{
        private int num; //每次生产的数量
        private Storge storge;
        private String name;
        
        public Producer(int num,Storge storge,String name){
            this.num = num;
            this.storge = storge;
            this.name = name;
        }
        
        public void run(){
            produce(num,name);        
        }
        public void produce(int num ,String name){
            storge.produce(num,name);
        }
    }


    //消费类
    class Consumer extends Thread{
        private int num ; //设置每次消费数目
        private Storge storge; //设置仓库
        private String name;
        
        public Consumer(int num,Storge storge,String name){
            this.num = num;
            this.storge = storge;
            this.name = name;
        }
        
        
        public void run(){
            consume(num,name);    
        }
        
        public void consume(int num,String name){
            storge.consume(num,name);
        }
        
        main()方法中
        //仓库对象
        Storge storge = new Storge();
        
        //生产对象
        Producer p1 = new Producer(20,storge,"p1");
        Producer p2 = new Producer(30,storge,"p2");
        Producer p3 = new Producer(50,storge,"p3");
        Producer p4 = new Producer(10,storge,"p4");
        Producer p5 = new Producer(10,storge,"p5");
        Producer p6 = new Producer(80,storge,"p6");
        
        
        //消费对象
        Consumer c1 = new Consumer(50,storge,"c1");
        Consumer c2 = new Consumer(20,storge,"c2");
        Consumer c3 = new Consumer(30,storge,"c3");
        
    }*/
    
    /*2.await() / signal()方式(可取代第一种方式)
    第一步：引入相关包
    import java.util.concurrent.locks.Condition;  
    import java.util.concurrent.locks.Lock;  
    import java.util.concurrent.locks.ReentrantLock;
    
    第二步：重写仓库类
    class Storge{
        private final int MAX_SIZE = 100;
        private LinkedList<Object> list = new LinkedList<Object>();
        private final Lock lock = new ReentrantLock();  //添加锁对象
        private final Condition full = lock.newCondition();//添加条件1
        private final Condition empty = lock.newCondition();//添加条件2
        
        public int getMAX_SIZE(){
            return MAX_SIZE;
        }
        
        public void setList(LinkedList<Object> list){
            this.list = list;
        }
        
        public LinkedList<Object> getList(){
            return list;
        }
        public Storge(){
            
        }
        
        //生产
        public void produce(int num,String name){
            lock.lock();//加锁
                while(list.size() + num > MAX_SIZE ){ //判断会不会满仓溢出
                    System.out.println("要生产的产品数量：" + num + " 库存量：" 
                                        + list.size() + "  " + name +"暂时不能执行生产任务");
                    try{
                        full.await();//设置生产阻塞状态  
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
                for(int i = 1; i <= num ;i++){
                    list.add(new Object());//生产
                }
                System.out.println(name + "已经生产了产品数量：" + num + " 库存量现在为:" + list.size());
                full.signalAll();//唤醒其他等待线程
                empty.signalAll();
                lock.unlock(); //解锁
            
        }
        
        //消费
        public void  consume(int num,String name){
            lock.lock();//加锁
                while(num > list.size() ){//判断有没可消费的库存
                    System.out.println("要消费的产品数量：" + num + " 库存量：" 
                                        + list.size() + "  " + name +"暂时不能执行消费任务");
                    try{
                        empty.await();//设置消费阻塞状态
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                        
                }
                for(int i = 1; i <= num ;i++){
                    list.remove();//移除消费项
                }
                System.out.println(name + "已经消费了产品数量：" + num + " 库存量现在为:" + list.size());
                full.signalAll();//唤醒其他等待线程
                empty.signalAll();
                lock.unlock(); //解锁
            
        }
        
    }
    
    其他跟第一种方式一样 (达到无需修改main()方法中相关代码和消费类、生产类即可实现)
    //推荐以后使用此方式实现同步
    */
    
    /*3.BlockingQueue阻塞队列方式
    第一步：引入相关包
    import java.util.concurrent.LinkedBlockingQueue; 
    第二步：重写仓库类
    class Storge{
        private final int MAX_SIZE = 100;
        private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>();//定义一个可同步的list
        
        public int getMAX_SIZE(){
            return MAX_SIZE;
        }
        
        public void setList(LinkedBlockingQueue<Object> list){
            this.list = list;
        }
        
        public LinkedBlockingQueue<Object> getList(){
            return list;
        }
        public Storge(){
            
        }
        
        //生产
        public void produce(int num,String name){
            if(list.size() + num > MAX_SIZE ){ //判断会不会满仓溢出
                    System.out.println("要生产的产品数量：" + num + " 库存量：" 
                                        + list.size() + "  " + name +"暂时不能执行生产任务");
                    
                }
                for(int i = 1; i <= num ;i++){
                    try{
                        list.put(new Object());//生产
                    }catch(InterruptedException e){
                        e.printStackTrace(); 
                    }
                    System.out.println(name + "已经生产了产品数量：" + num + " 库存量现在为:" + list.size());
                }
                
            
        }
        
        //消费
        public void  consume(int num,String name){
            
            if(num > list.size() ){//判断有没可消费的库存
                System.out.println("要消费的产品数量：" + num + " 库存量：" 
                                + list.size() + "  " + name +"暂时不能执行消费任务");
                }
            for(int i = 1; i <= num ;i++){
                try{
                    list.take();//移除消费项
                }catch(InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(name + "已经消费了产品数量：" + num + " 库存量现在为:" + list.size());    
            }    
        }
        
    }
    其他跟第一种方式一样 (达到无需修改main()方法中相关代码和消费类、生产类即可实现)
    但可能会出现put跟打印出来的结果不一样。
    */
    
    //总结：推荐使用第二种方式实现同步
    
    /**5.4 死锁**/
    //发生死锁的原因一般是两个对象的锁相互等待造成的
    
    /***5.5 volatile关键字**/
    //Java包含两种内在的同步机制：同步块（或方法）和 volatile变量。这两种机制的提出都是为了实现代码线程的安全性。
    //其中 Volatile变量的同步性较差（但有时它更简单并且开销更低），而且其使用也更容易出错。所以你可以忘了它了
    }
    
    /*
    *6.交互
    */
    public static void demoThreadInteraction(){
        /**6.1 交互关键字**/
        //notify关键字：唤醒在此对象监视器上等待的单个线程
        //notifyAll关键字：唤醒在此对象监视器上等待的所有线程
        //wait关键字：导致当前的线程等待，直到其他线程调用此对象的notify()方法或者notifyAll()方法
        //其中wait()方法有两个重载的方法：
        //    1.void wait(long timeout)————导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者超过指定的时间量。
        //    2.void wait(long timeout, int nanos) —————导致当前的线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。
    
    }
    
    /*
    *7.调度
    */
    public static void demoThreadDispatch(){
        /**7.1 休眠**/
        //休眠目的————————使线程让出CPU的最简单的做法之一，线程休眠时候，会将CPU资源交给其他线程，以便能轮换执行，当休眠一定时间后，线程会苏醒，进入准备状态等待执行
        //实现方式：Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)，均为静态方法，谁调用就休眠谁
        
        /**7.2 优先级**/
        //优先级高的线程获取CPU资源的概率较大
        //优先级用1-10之间的整数表示，默认为5
        //一般情况下，子线程优先级跟父线程一致
        
        /**7.3 让步**/
        //让步——————使当前运行着线程让出CPU资源，但是然给谁不知道，仅仅是让出，线程状态回到可运行状态。
        //实现方式：Thread.yield()方法，yield()为静态方法，功能是暂停当前正在执行的线程对象，并执行其他线程。
        
        /**7.4 合并**/
        //合并——————将几个并行线程的线程合并为一个单线程执行，应用场景是当一个线程必须等待另一个线程执行完毕才能执行
        //实现方式：调用join()方法  非静态方法
        //其中join方法重载方法有：
        //        1.void join()  等待该线程终止。    
        //        2.void join(long millis)  等待该线程终止的时间最长为 millis毫秒。    
        //        3.void join(long millis,int nanos) 等待该线程终止的时间最长为 millis毫秒 + nanos 纳秒。
        
        /**7.5 守护线程**/
        //守护线程———————为其他线程的运行提供服务
        //实现方式：线程对象的方法setDaemon(true)，则可以将其设置为守护线程
        //注意：
        //    1.调用setDaemon()必须在start()方法前
        //    2.Daemon线程中产生的新线程也是Daemon的
        //    3.不是所有的应用都可以分配给Daemon线程来进行服务(因为有可能线程还没来得及进行操作时，虚拟机就已经退出了)
        
    }
    
    /*
    *8.新特征
    */
    public static void demoThreadNewFeatures(){
        //新特性指的是在Java6及之后版本所拥有线程相关的新特性
        /**8.1 线程池**/
        //线程池分好多种：固定尺寸的线程池、单任务线程池、可变尺寸连接池、延迟连接池、自定义线程池等
        ExecutorService pool_1 = Executors.newFixedThreadPool(3);//创建一个固定可重用的线程池 容量为3
        ExecutorService  pool_2 =  Executors.newSingleThreadExecutor();//创建一个单任务线程池
        ExecutorService pool_3 =  Executors.newCachedThreadPool();//创建一个可变尺寸的线程池 
        ScheduledExecutorService  pool_4 =  Executors.newScheduledThreadPool(4);//创建一个延迟线程池
        
        Thread t1 = new testPool();
        Thread t2 = new testPool();
        Thread t3 = new testPool();
        Thread t4 = new testPool();
        
        
        System.out.println("固定可重用的线程池演示！");
        //将线程放入线程池中执行
        pool_1.execute(t1);
        pool_1.execute(t2);
        pool_1.execute(t3);
        pool_1.execute(t4);
        pool_1.shutdown();//关闭
        
        System.out.println("单任务线程池演示！");
        pool_2.execute(t1);
        pool_2.execute(t2);
        pool_2.execute(t3);
        pool_2.shutdown();//关闭
        
        System.out.println("可变尺寸线程池演示！");
        pool_3.execute(t1);
        pool_3.execute(t2);
        pool_3.execute(t3);
        pool_3.shutdown();//关闭*/
        
        System.out.println("延迟线程池演示！");
        pool_4.execute(t1);
        pool_4.execute(t2);
        
         //使用延迟执行风格的方法
         //第一个参数是延迟执行线程对象，第二个参数是延迟数量，第三个参数是延迟的单位
        pool_4.schedule(t3, 1000, TimeUnit.MILLISECONDS); //t3 延迟 1000毫秒
        pool_4.schedule(t4, 10, TimeUnit.SECONDS); //t4 延迟 10秒
        pool_4.shutdown();//关闭
        
        /**8.2 有返回值的线程**/
        //可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口(Thread类也实现Runnable接口)
        //实现方式：执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了
        /*
        
        class MyCallable implements Callable{
            private String oid;

            MyCallable(String oid) { 
                    this.oid = oid;
            } 

            @Override 
            public Object call()throws Exception {
                    return oid+"任务返回的内容";
            }
        }
        
        public static void main(String[] args)throws ExecutionException, InterruptedException {
                //创建一个线程池
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                
                //创建两个有返回值的任务
                Callable c1 = new MyCallable("A");
                Callable c2 = new MyCallable("B");
                
                //执行任务并获取Future对象
                Future f1 = pool.submit(c1); 
                Future f2 = pool.submit(c2); 
                
                //从Future对象上获取任务的返回值，并输出到控制台
                System.out.println(">>>"+f1.get().toString());
                System.out.println(">>>"+f2.get().toString());
                
                //关闭线程池
                pool.shutdown(); 
        } 
        
        //更多使用详见API文档
        */
        
        /**8.3 锁**/
        /**具体使用参考本文上面的生产者和消费者模型的第二种实现方式**/
        
        /**8.4 信号量**/
        /*
        信号量实际上是一个功能完毕的计数器，对控制一定资源的消费与回收有着很重要的意义，信号量常常用于多线程的代码中，
              并能监控有多少数目的线程等待获取资源，并且通过信号量可以得知可用资源的数目等等，这里总是在强调“数目”二字，
              但不能指出来有哪些在等待，哪些资源可用。
        貌似用处不大，使用的时候再查看相关文档即可
        */
        
        /**8.5 阻塞队列**/
        /**具体使用参考本文上面的生产者和消费者模型的第三种实现方式**/
        
        /**8.6 阻塞栈**/
        /**用法与阻塞队列相似，不同的是栈是后入先出的结构，每次操作都是栈顶元素，而队列则是先进先出结构，每次操作都是队头**/
        
        /**8.7 条件变量**/
        /**具体使用参考本文上面的生产者和消费者模型的第二种实现方式**/
        
        /**8.8 原子量**/
        //原子量：操作变量的操作是原子的，不可再分
        /*
        class MyRunnable implements Runnable {
            privatestatic AtomicLong aLong =new AtomicLong(10000);        //原子量，每个线程都可以自由操作
            private String name;                //操作人
            privateint x;                            //操作数额
            private Lock lock;

            MyRunnable(String name, int x,Lock lock) {
                    this.name = name;
                    this.x = x;
                    this.lock = lock;
            } 

            publicvoid run() {
                    lock.lock(); 
                    System.out.println(name + "执行了" + x +"，当前余额：" + aLong.addAndGet(x));
                    lock.unlock(); 
        } 
        
         public static void main(String[] args) {
                ExecutorService pool = Executors.newFixedThreadPool(2); 
                Lock lock = new ReentrantLock(false);
                Runnable t1 = new MyRunnable("张三", 2000,lock);
                Runnable t2 = new MyRunnable("李四", 3600,lock);
                Runnable t3 = new MyRunnable("王五", 2700,lock);
                Runnable t4 = new MyRunnable("老张", 600,lock);
                Runnable t5 = new MyRunnable("老牛", 1300,lock);
                Runnable t6 = new MyRunnable("胖子", 800,lock);
                //执行各个线程
                pool.execute(t1); 
                pool.execute(t2); 
                pool.execute(t3); 
                pool.execute(t4); 
                pool.execute(t5); 
                pool.execute(t6); 
                //关闭线程池
                pool.shutdown(); 
        } 
        
        */
        /**8.9 障碍器**/
        //障碍器是多线程并发控制的一种手段。
        //应用场景：如果一个主干任何中有许多子任务需要执行，那么只有在所有子任务执行完毕后，主任务才能执行
        
        //构造主任务障碍器  第一个参数子任务个数，第二参数主任务对象
        CyclicBarrier cb = new CyclicBarrier(7,new MainTask()); 
        
        new Thread(new SubTask("A",cb)).start();//创建子任务线程
        new Thread(new SubTask("B",cb)).start();
        new Thread(new SubTask("C",cb)).start();
        new Thread(new SubTask("D",cb)).start();
        new Thread(new SubTask("E",cb)).start();
        new Thread(new SubTask("F",cb)).start();
        new Thread(new SubTask("G",cb)).start();
        
    }    
    
    /**部分文档参考出处：http://blog.csdn.net/shimiso**/
}