黑马程序员技术交流社区

标题: 多线程3 [打印本页]

---

作者: 董将    时间: 2012-12-7 23:44
标题: 多线程3
同步的好处：
                解决了多线程的安全问题。
       
        同步的弊端：
                1，相对消耗资源。
                2，容易出现死锁。(当这个同步嵌套的时候容易出现，大家在开发时，尽量避免。)

        为了面试：
               
        //定义锁类。
        class MyLock
        {
                static MyLock locka = new MyLock();
                static MyLock lockb = new MyLock();
        }

        class Demo implements Runnable
        {
                private boolean flag ;
                Demo(boolean flag)
                {
                        this.flag = flag;
                }
                public void run()
                {
                        if(flag)
                        {
                                while(true)
                                {
                                        synchronized(MyLock.locka)
                                        {
                                                System.out.println("if......locka");
                                                synchronized(MyLock.lockb)
                                                {
                                                        System.out.println("if......lockb");
                                                       
                                                }
                                        }
                                }
                        }
                        else
                        {
                                while(true)
                                {
                                        synchronized(MyLock.lockb)
                                        {
                                                System.out.println("else......lockb");
                                                synchronized(MyLock.locka)
                                                {
                                                        System.out.println("else......locka");
                                                       
                                                }
                                        }
                                }
                        }
                }
        }

        class DeadLockDemo
        {
                public static void main(String[] args)
                {
                        Demo d1 = new Demo(true);
                        Demo d2 = new Demo(false);

                        new Thread(d1).start();
                        new Thread(d2).start();
                }
        }
       

        -----------------------------------

        线程间通信。
        多个线程在处理同一个数据资源，但是处理的动作却不一致。
        这里就用到一个机制  等待/唤醒 机制。

        等待和唤醒：
        wait():让线程处于等待状态。这时线程会释放锁。并存入到了线程池中。
        notify()：通常唤醒线程池中的第一个。
        notifyAll()：将线程池中的所有等待线程都唤醒。

        这三个方法都需要定义在同步当中。因为要标识出它们所作用的锁。
        如果用在同步外，有可能发生 无效线程状态异常。
        三个方法为什么定义在Object类中？因为锁可以任意对象，被任意对象都能调用的方法肯定定义在Object类。
       
        //需求：两个线程对同一个资源进行操作，一个赋值姓名和性别，一个线程负责打印姓名和性别。
        //1,定义资源。
        class Res
        {
                private String name;
                private String sex;
                private boolean flag = false;
                public synchronized  void set(String name,String sex)
                {
                        if(flag)
                                try{this.wait();}catch(InterruptedException e){}                       
                        this.name = name;
                        this.sex = sex;
                        flag = true;
                        this.notify();
                }

                public synchronized void out()
                {
                        if(!flag)
                                try{this.wait();}catch(InterruptedException e){}
                        System.out.println(name+"..."+sex);
                        flag = false;
                        this.notify();
                }
        }
       
        class Input implements Runnable
        {
                private Res r;
                Input(Res r)
                {
                        this.r = r;
                }
                public void run()
                {
                        int x = 0;
                        while(true)
                        {
                                if(x==0)
                                {
                                        r.set("mike","nan");
                                }
                                else
                                        r.set("丽丽","女女");
                                x = (x+1)%2;
                        }
                }
        }

        class Output implements Runnable
        {
                private Res r;
                Output(Res r)
                {
                        this.r = r;
                }
                public void run()
                {
                        while(true)
                        {
                                r.out();
                        }
                }
        }

        class ResDemo
        {
                public static void main(String[] args)
                {
                        Res r = new Res();

                        new Thread(new Input(r)).start();
                        new Thread(new Output(r)).start();
                }
        }

        wait()和sleep()的特点：
        wait：可以有时间限定，也可以没有时间限定。
        sleep：必须有时间限定。

        wait：释放cpu执行资源，也释放锁。
        sleep：释放cpu执行资源，不释放锁。
        ----------------------------------------

        线程间通信的演化。
        需求：
        当多个线程进行通信时，一部分线程在进行存储动作，一部分线程在进行取出动作。
        无论多少个线程进行存储，只有可以可以执行，无论多少个线程进行取出，只能取出一次。
       
        class Res
        {
                private String name;
                private boolean flag;
                private int count = 0;

                public synchronized void set(String name)throws InterruptedException
                {
                        while(flag)
                                wait();
                        this.name = name;
                        add();
                        System.out.println(Thread.currentThread().getName()+"----生产----"+name+"::"+count);
                        flag = true;
                        notifyAll();

                }
                public synchronized void out()throws InterruptedException
                {
                        while(!flag)
                                wait();
                        System.out.println(Thread.currentThread().getName()+"....消费...."+name+"::"+count);
                        flag = false;
                        notifyAll();
                }
                public void add()
                {
                        count++;
                }
        }

        class Input implements Runnable
        {
                private Res r;
                Input(Res r)
                {
                        this.r = r;
                }
                public void run()
                {
                        while(true)
                        {
                                try{r.set("商品");}catch(InterruptedException e){}
                        }
                }
        }
        class Output implements Runnable
        {
                private Res r;
                Output(Res r)
                {
                        this.r = r;
                }
                public void run()
                {
                        while(true)
                        {
                                try{r.out();}catch(InterruptedException e){}
                        }
                }
        }

        class ResDemo
        {
                public static void main(String[] args)
                {
                        Res r = new Res();

                        //创建两个生成者
                        new Thread(new Input(r)).start();
                        new Thread(new Input(r)).start();
                        //创建两个消费者
                        new Thread(new Output(r)).start();
                        new Thread(new Output(r)).start();
                }
        }

        发现结果不爽！要么就生产不断的生产，却没有被消费，要么就是消费者不断的消费，却没有生产。
        当然在某一时段，也会出现和谐情况。多运行就会不和谐。

        发生的原因的是：当线程等待时。再次被唤醒，不会在去判断标记flag。
        那么就会发生数据错乱的情况。

        解决办法：一定要醒来的线程再一次判断标记。所以要将判断的标记的if改成while。
        这时就将if(flag)改成while(flag).

        该完以后，发现，郁闷了，线程和不和谐不重要，程序虽然没有结束，但是生产者消费者都不再运行，
        因为都处于wait状态。

        原因：是出现循环判断后，线程每一次都判断标记，都会出现等待的情况，
        例如：3个线程等待，第四个线程，唤醒了其中一个，而这一个也是和该线程属于同一方的。

        解决：希望可以唤醒另一放的线程。比如：消费需要去唤醒生产的。
        而在Object提供的监视器方法中只提供了notify，和notifyAll进行唤醒。
        所以这时可以使用notifyAll，将所有等待的线程都唤醒，这些线程中就包括对方线程。

        就需要将代码中的notify改成notifyAll。

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2