黑马程序员——>第十二天<多线程(线程间通信-守护线程)>

-------android培训、java培训、期待与您交流-------

01多线程(线程间通信-示例代码)
  线程间通信：我们有一堆资源，a线程在往里边存数据，b线程在往外面取数据，这一进一出在同时运行，这就涉及到多线程。这两个线程运行代码不一致，一个负责往里边存数据，另一个往外边拿数据。所以动作不一致，就代表着有两个run方法来存放，两个run方法存放在两个类当中。
Input  资源   Output

思考：
01
 wait(),notify(),notifyAll(),用来操作线程为什么定义在了Object类中？
1这些方法存在于同步中
2使用这些方法时必须要标识所属的同步的锁
3锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中
思考：
02
wait(),sleep()有什么区别
 wait();   释放资源，释放锁
 sleep();  释放资源，不释放锁

线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。

多线程(线程间通信-解决安全问题)
解决方式：同步

02多线程(线程间通信-等待唤醒机制)
等待唤醒机制：
为了满足条件需求，在同步中加入一个标记boolean flag = false
输入线程在往里输入数据时先判断标记叫做里边有没有值。当里面是false时，就往里边存一个数据，
存完后输入线程还持有cpu执行权，那么这时候，它在存完数据以后，它就会做一件事情：将标记改为true，代表里边有数据。当输入线程继续拿到cpu执行权后回来判断为true了，就不往里存了。这时就让输入线程在那里等着别动(wait()  冻结(放弃了执行资格))，这时就这剩下输出线程了。在输出时要判断里边有没有东西，true就取走，打印一次，然后将true改为false。还持有cpu执行权，进去后发现为false，就等着不动。如果这样，两个都等，程序及挂。所以，输出线程在等之前要将输入线程叫醒。然后在输入线程完成输入动作后等之前将输出线程叫醒

这种情况在开发中非常常见。

class Res
{
 String name;
 String sex;
 boolean flag = false;
}

class Input implements Runnable
{
 private Res r ;
 Input(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  int x = 0;
  while(true)
  {
   synchronized(r)
   {

    if(r.flag)
     try{r.wait();}catch(Exception e){}
    if(x==0)
    {
     r.name="mike";
     r.sex="man";
    }
    else
    {
     r.name="丽丽";
     r.sex = "女女女女女";
    }
    x = (x+1)%2;
    r.flag = true;
    r.notify(); // 叫醒
等待线程都存在线程池当中，notify唤醒的都是线程池中的线程，通常唤醒第一个被等待的。
   }
  }
 }
}

class Output implements Runnable
{
 private Res r ;
 
 Output(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  while(true)
  {
   synchronized(r)
   {
    if(!r.flag)
     try{r.wait();}catch(Exception e){}
           // 必须标示wait所持的锁r.wait   因为同步会出现嵌套，出现俩锁
    System.out.println(r.name+"...."+r.sex);
    r.flag = false;
    r.notify(); // 标识锁
   }
  }
 }
}


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

  Input in = new Input(r);
  Output out = new Output(r);

  Thread t1 = new Thread(in);
  Thread t2 = new Thread(out);

  t1.start();
  t2.start();
 }
}

//notifyAll();  //全叫醒

 

/*
wait:
notify();
notifyAll();
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

03多线程(线程间通信-生产者消费者)

对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

04多线程(线程间通信-生产者消费者jdk1.0升级版)

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

提供了显示的锁机制，以及显示的锁对象上的等待唤醒操作机制，同时将等待唤醒进行了封装，封装完后一个锁可以对应多个Condition对象，

Lock:替代了Synchronized
 lock   获取锁
 unlock  释放锁
 newCondition() 返回绑定到此lock实例的新Condition实例

Condition：替代了Object wait notify notifyAll
 await();   造成当前线程在接到信号或被中断之前一直处于等待状态
 signal();  唤醒一个等待线程
 signalAll(); 唤醒所有等待线程

05多线程(停止线程)

1.定义循环结束标记
  因为线程运行代码一般都是循环，只要控制了循环即可
2.使用interrupt(中断)方法
  该方法是结束线程的冻结状态，使线程回到运行状态中来
注：stop方法已经过时不再使用

 

stop方法已经过时。

如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：
当线程处于了冻结状态。
就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

 

06多线程(守护线程)
setDaemon
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，java虚拟机退出。
该方法必须在启动线程前调用。

class  StopThreadDemo
{
 public static void main(String[] args) 
 {
  StopThread st = new StopThread();
  
  Thread t1 = new Thread(st);
  Thread t2 = new Thread(st);
                t1.setDaemon(true);
                t2.setDaemon(true); //  (守护线程   后台线程)
  t1.start();
  t2.start();

  int num = 0;

  while(true)
  {
   if(num++ == 60)
   {
    //st.changeFlag();
    t1.interrupt();
    t2.interrupt();
    break;
   }
   System.out.println(Thread.currentThread().getName()+"......."+num);
  }
  System.out.println("over");
 }
}

 

后台线程的特点是：开启后和前台线程共同抢劫cpu的执行权运行，当所有的前台线程都结束后，后台线程会自动结束。(后台依赖前台)
07多线程(Join方法)

join:     等待该线程终止
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。

join可以用来临时加入线程执行。

 

class Demo implements Runnable
{
 public void run()
 {
  for(int x=0; x<70; x++)
  {
   System.out.println(Thread.currentThread().toString()+"....."+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();
  t2.start();

  //t1.join();

当join在下面时：主线程开启了t1，t2。这个时候执行权在主函数手里，当主函数碰到t1.join提交加入，主函数停下来冻结。释放了执行权(碰到join是释放了执行权而不是将执行权给t1)，而这个时候有两个线程t1，t2，都具备执行资格，这个时候cpu就开始对t1和t2进行交替执行。可是，主线程什么时候活？主线程要等到t1结束，至于t2结束不结束跟主函数没有关系。如果t1结束了，t2还没结束，主函数就已经醒啦，主函数会和t2抢夺执行权执行。    主函数碰到谁的join，就等谁。它把执行权放出去后，谁拿着抢它不管，它就等谁让它把执行权放出来它就等谁执行完，这就是join方法的特点

08多线程(优先级&amp；amp；yield方法)
yield方法：暂停当前正在执行的线程对象，并执行其他线程。
当某些代码需要同时被执行时，就用单独的线程进行封装，你可以封装三个类出来，
独立运行相互不相干时，封装一下就可以了

 

 

-------android培训、java培训、期待与您交流-------