/*API 1.5
JDK1.5 中提供了多线程升级解决方案
将同步synchronized替换成现实Lock操作
将Object中的wait，notify，notifyAll替换成Condition对象
该对象可以Lock锁进行获取。
该示例中，实现了本方只唤醒对方操作。
*/


import java.util.concurrent.locks.*;
class ProducerConsumerDemo
{
        public static void main(String[] args)
        {
                Resource r = new Resource();
                Producer pro = new Producer(r);
                Consumer con = new Consumer(r);
                Thread t1 = new Thread(pro);
                Thread t2 = new Thread(con);
                t1.start();
                t2.start();
        }
}
class Resourse
{
        private String name;
        private int count =1;
        private boolean flag =false;
        private Lock lock = new ReentrantLock();
        private Condition condition_pro = lock.newCondition();
        private Condition condition_con = lock.newCondition();
        public  void set(String name)throws InterruptedException
        {
                lock.lock();
                try
                {
                        while(flag)
                                condition_pro.await();
                        this.name = name +"--"+ count++;
                        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
                        flag = true;
                        condition_con.signalAll();
                }
                finally
                {
                        lock.unlock();//释放锁的动作一定会执行
                }
        }
        public  void out()throws InterruptedException
        {
                lock.lock()
                try
                {
                        while(!flag)
                                condition_con.await();
                        System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
                        flag = false;
                        condition_pro.signalAll();
                }
                finally
                {
                        lock.unlock();
                }
        }
}
class Producer implements Runnable
{
        private Resource res;
        Producer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        try
                        {
                                res.set("++商品++");
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
        }
}
class Consumer implements Runnable
{
        private Resource res;
        Consumer(Resource res)
        {
                this.res = res;
        }
        public void run()
        {
                while(true)
                {
                        try
                        {
                                res.out();
                        }
                        catch (InterruptedException e)
                        {
                        }
                }
        }
}
/*
停止线程
1，定义循环结束标记
        因为线程运行代码一般都是循环，只要控制了循环即可。
2，使用interrupt(中断)方法
        该方法是结束线程的冻结状态，使线程回到运行状态中来
        注意：stop方法已经过时不再使用。
stop方法已经过时，如何停止线程？只有一种，run方法结束
开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。


特殊情况：
当线程处于了冻结状态，就不会读取到标记，那么线程就不会结束。
当没有指定方式让冻结的线程恢复到运行状态时，
这时需要对冻结进行清除。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束

Thread类提供该方法interrupt();
守护线程setDaemon();在启动线程前调用，当前台线程结束，后天线程自动结束。



*/
class StopThread implements Runnable
{
        private boolean flag = true;
        public void run()
        {
                while(flag)
                {
                        System.out.println(Thread.currentThread().getName()+"....run");
                }
        }
        public void changeFlag()
        {
                flag = false;
        }
}
class StopThreadDemo
{
        public static void main(String [] args)
        {
                StopThread st = new StopThread();
                Thread t1 = new Thread(st);
                Thread t2 = new Thread(st);
                t1.start();
                t2.start();
                int num = 0;
                while(true)
                {
                        if(num++==60)
                        {
                                st.changeFlag();
                                break;
                        }
                        System.out.println(Thread.currentThread().getName()+"...."+num);
            }
        }
}

//join()示例
join 特点：当A线程执行到B线程的.join()方法时，就会等待，等待B线程都执行完，A才会执行。
join可以用来临时加入线程执行。

class Demo implements Runnable
{
        public void run()
        {
                for(int x =0; x<70; x++)
                {
                        System.out.println(Thread.currentThread().getName()+"...."+x);
                }
        }
}
class joinDemo
{
        public static void main(String [] args)throws Exception
        {
                Demo d = new Demo()
                Thread t1 = new Thread(d);
                Thread t2 = new Thread(d);
                t1.start();
                t1.join();//抢夺CPU执行权
                t2.start();
                for(int x=0; x<80; x++)
                {
                        System.out.prinln("main..."+x);
                }
                System.out.println("over");
        }
}

开发时写线程
class ThreadTest
{
        public static void main(String [] args)
        {
                new Thread()
                {
                        public void run()
                        {
                                for(int x=0; x<100; x++)
                                {
                                        System.out.println("...."+x);
                                }
                        }       
                }.start();
                for(int x=0; x<100; x++)
                {
                        System.out.println("...."+x);
                }
                Runnable r = new Runnable()
                {
                        public void run()
                        {
                                for(int x=0; x<100; x++)
                                {
                                        System.out.println("...."+x);
                                }
                        }       
                };
                new Thread(r).start();
        }
}

学习了