线程分析.....

一、 线程同步
关键字：synchronized
同步问题：当多个线程操作同一个对象时，就会出现线程对象对自己操作的数据不同步的问题。如下图：

synchronized方法：
1、synchronized代码块中的语句只能有一个线程在执行
2、任意一个对象都有一个标志位，有1和0两种状态
3、当程序执行到synchronized代码块的时候线程会检查对象的标志位是1还是0
4、如果是1则执行程序，同是将对象的标志位设置为0，其他线程执行到synchronized代码块时一看对象标志位为0 则线程会阻塞，一直等到对象的标志位为1再执行下面的程序

注意：在用synchronized标志对象时，对象必须是同一个对象才能保证线程同步

如：生产者与消费者模拟，生产者和消费者共同操作同一集合，当集合为空时，生产者生产一件商品放进集合，同时，消费者检测集合不为空，则买走一件东西，集合又为空，如此循环。

//商品类
public class Iphone {
    public String name;
    public Iphone(String name) {
        this.name = name;
    }
public static void main(String[] args) {
        // 创建两个线程对象
        ArrayList<Iphone> list = new ArrayList<Iphone>();  //构建队列，如此，保证消费者与生产者操作同一个队列
        Consumer con = new Consumer(list);  
        Producer pro = new Producer(list);

        pro.start();
        con.start();
    }
}

/**
 * 生产者类
 */
public class Producer extends Thread {
    ArrayList<Iphone> list;  //此为消费者与生产者共同操作的队列
    int value;  //商品型号

    public Producer(ArrayList<Iphone> list) {
        this.list = list;
    }

    public void run() {  
        synchronized (list) {  //保证线程同步
            while (true) {
                if (list.size() > 0) {
                    try {
                        list.wait(); //当队列不为零时，生产者不生产商品
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //队列为零，生产者生产商品
                Iphone ih = new Iphone("iphone6S\t" + value);
                list.add(ih);  //生产的商品添加到队列
                value++;    //商品型号改变            
                System.out.println("生产了一个手机，型号为:" + ih.name);
                list.notify(); // 释放，告诉消费者队列有商品，与阻塞方法并存
            }
        }
    }

}

/**
 * 消费者类
 * 
 */
public class Consumer extends Thread {
    ArrayList<Iphone> list;  //共同的队列

    public Consumer(ArrayList<Iphone> list) {
        this.list = list;
    }

    public void run() {
        synchronized (list) {  //线程同步锁
            while (true) {
                if (list.size() == 0) {  //检测队列中是否有商品
                    try {
                        list.wait(); // 没有商品，则不执行下面的代码，阻塞
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //如果有商品，则买走
                Iphone ih = list.remove(0); // 移除队列中第一个数据
                System.out.println("买走了一个手机，型号为" + ih.name);
                list.notify(); // 告诉生产者，释放
            }

        }

    }
}

运行结果：保证了生产者与消费者平衡，线程同步

其中，运用到了wait和notify两个机制；
它们的作用是：一个是等待，一个是通知，当在一个对象上调用wait()方法时，当前线程就会进行等待状态，直到收到另一个对象的notify()发出通知，才会执行下一步计算

注意：1、必须在synchronized关键字也就是同步锁中运用；
2、同步锁锁定对象和wait、notify对象必须同一个；
3、当对象wait挂起状态时候是会释放同步锁的，也就是同步锁的对象标志位变为1。

二、线程池
1、线程生命周期

线程弊端：当线程run方法执行完毕后，线程也就死亡，同时同一个线程不能start两次。
如果一个线程需要多次执行，就需要线程池。

自定义线程池：

public class ThreadPool {
public ThreadPool(){
        //预置好10个执行线程
        for(int i=0;i<10;i++){  //
            PoolWorker worker = new PoolWorker(taskList);
            worker.start();//启动线程
        }
        System.out.println("******************线程池预置完毕**************************");
    }
    public static void main(String[] args) {
        //创建.线程池对象
        ThreadPool pool = new ThreadPool();
        //决定线程执行次数
        for(int i=0;i<60;i++){
            MyTask task = new MyTask();  //线程执行方法类
            pool.excute(task);  //线程执行
        }
    }
}

public class MyTask {  //线程执行的方法类
     ........
}
}

2、JDK内置的线程池：
java.util. concurrent包
JDK1.5起，引入的包，这个包下是关与并发编程使用的类库
java.util.concurrent.ExecutorService

//使用JDK内置的线程池，创建具有5个内置线程的池
ExecutorService exec = Executors.newFixedThreadPool(5); 
//创建50个任务    
for(int index = 0; index < 50; index++) {
     SamplTask st=new SamplTask();
     //开始执行
     exec.execute(st);
 }
//执行完任务后再关闭线程池，
exec.shutdown();