黑马程序员java学习—多线程2：等待唤醒机制

同步函数：

只有当同步代码块和同步函数封装的内容是一样的时候，才可以直接将同步关键字作为修饰符修饰函数即可。

这样函数就具备了同步性。

这就是同步函数。同步的另一种表现形式。

这种表现形式较为简单。

同步函数使用锁是this 。是调用同步函数的对象。

同步函数和同步代码块有什么区别呢？

1，同步函数比同步代码块写法简单。

2，同步函数使用的锁是this。同步代码块使用的锁是任意指定的对象。

建议开发时，使用同步代码块。尤其是需要不同锁时。

静态同步函数使用的锁是什么？

静态随着类的加载而加载的，这时内存中存储的对象至少有一个

就是该类字节码文件对象。

这个对象的表示方式 类名.class 它就表示字节码文件对象。 

 

饿汉式。

class Single

{

     private static final Single s = new Single();

     private Single(){}

     public static Single getInstance()

    {

        return s;

    }

}

 

懒汉式

在被多线程并发访问时，会出现多线程安全问题。

为了解决，加入了同步，虽然安全问题解决了，

但是性能降低了。

有没有办法将安全问题解决的同时，还可以提高性能。

解决改进方法：改成同步代码块。 

可以通过双重判断的形式来完成这个过程。 

class Single

{

      private static Single s = null;

      private Single(){}

      public static  Single getInstance()

     {

         if(s==null)// -->0 -->1

        {

           synchronized(Single.class)

           {

                if(s==null)// -->0 -->1

                s = new Single();

           }

          }

          return s;

    }

}

同步的另一个弊端：死锁。

最常见的死锁情况：同步嵌套。

同步中还有同步，两个同步用的不是一个锁。 

记住尽量避免同步嵌套的情况。

在0和1之间不断变换

if(x==1){}

else{}

x=(x+1)%2;

线程间通信：多个线程在处理同一个资源。 但是处理的动作(线程的任务)却不相同。

等待唤醒机制。

涉及到的方法：

wait():等待，将正在执行的线程释放其执行资格和执行权，并存储到线程池中。

notify():唤醒，唤醒线程池中被wait的线程，一次唤醒一个，而且是任意的。

notifyAll():唤醒全部，可以将线程池中的所有wait线程都唤醒，

唤醒的意思就是让线程池中的线程具备执行资格。

这些方法都要使用在同步中才有效。

这些方法在使用时必须标明所属锁，这样才可以明确出这些放操作的到底是哪个锁上的线程。

为什么这些操作线程的方法定义在Object类中？

因为这些方法在使用时，必须要标明所属的锁，而锁又可以是任意对象。

能被任意对象调用的方法一定定义在Object类中。

代码演示

synchronized(r)

{

 if(r.flag){

             try{r.wait();}

             catch(InterruptedException e){}

             }

if(x==0)

{

         r.name = "Mike";

         r.sex = "man";

}

else

{

         r.name = "小红";

         r.sex = "女";

}

r.flag = true;

r.notify();

}

synchronized(r)

{

      if(!r.flag)

{

      try{r.wait();}

      catch(InterruptedException e){}

}

      System.out.println(r.name+"....."+r.sex);

      r.flag = false;

      r.notify();

}

多生产者多消费者问题。

发生的问题：

生产者生产的商品没有被消费就生产了新的商品。

问题在于两点：

1，本方唤醒了本方。

2，被唤醒的本方没有判断标记。只要将if判断该外while判断。 

将if改为while循环判断标记后，出现了死锁。

因为本方唤醒了本方，而被唤醒的本方一判断标记，就继续等待。这样所有的线程都等待了。

必须唤醒对方才行，但是没有直接唤醒对方的动作，所以就使用了notifyAll，唤醒全部。 

这个程序有一个bug。就是每次notifyAll。都会唤醒本方。
可不可以只唤醒对方呢？

JDK1.5版本提供了一些新的对象，优化了等待唤醒机制。

1，将synchronized 替换成了Lock接口。
  将隐式锁，升级成了显示锁。
   Lock
  获取锁：lock();
  释放锁：unlock();注意：释放的动作一定要执行，所以通常定义在finally中。
  获取Condition对象：newCondition();
2，将Object中的wait，notify，notifyAll方法都替换成了Condition的await，signal，signalAll。
 和以前不同是：一个同步代码块具备一个锁，该所以具备自己的独立wait和notify方法。
 现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。

 Lock lock = new ReentrantLock();

 Condition conA = lock.newCondition();
 Condition conB = lock.newCondition();

 con.await();//生产，，消费

 

 con.signal();生产

 set()
 {
    if(flag)
   conA.await();//生产者，
   code......;

  flag = true;
  conB.signal();
 }
 
 out()
 {
  if(!flag)
   conB.await();//消费者

  code....;
  flag = false;
  conA.signal();
 }

 

wait和sleep的区别：
wait:释放cpu执行权，释放同步中锁。
sleep:释放cpu执行权，不释放同步中锁。

synchronized(锁)
{
 wait();
}

停止线程：
 stop过时。
 原理：run方法结束。run方法中通常定义循环，指定控制住循环线程即可结束。

 1，定义结束标记。
 2，当线程处于了冻结状态，没有执行标记，程序一样无法结束。
  这时可以循环，正常退出冻结状态，或者强制结束冻结状态。
  强制结束冻结状态：interrupt();目的是线程强制从冻结状态恢复到运行状态。
  但是会发生InterruptedException异常。