黑马程序员_day12 多线程(线程间通信，停止线程，守护线程，Join方法，优先级)

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

一：线程间通信。

 1,Input -->资源 -->Output

 2,思考1：wait(),notifyAll(),用来操作线程为什么定义在了Object类中？

  a,这些方法存在于同步中。

  b,使用这些方法时必须要表示所属的同步的锁。

  c,锁可以使任意对象，所以任意对象调用的方法一定定义Object类中。

 思考2：wait(),sleep()有什么区别?
  
  a,wait():释放资源，释放锁。

  b,sleep():释放资源，不释放锁。

二：同步.java。

进程：正在执行的程序。

线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)

进程中至少有一个线程。

对于JVM，启动时，只好有两个线程：jvm的主线程。jvm的垃圾回收线程。

如何在程序中自定义线程呢？

Java给我们提供了对象线程这类事物的描述。该类是Thread

该类中定义了，
创建线程对象的方法(构造函数).
提供了要被线程执行的代码存储的位置（run()）

还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程：
 static Thread currentThead():
 String getName():
 static void sleep(time)throws InterruptedException:

要运行的代码都是后期定义的。
所以创建线程的第一种方式是：继承Thread类。原因：要覆盖run方法，定义线程要运行的代码。

步骤：
1，继承Thread类。
2，覆盖run方法。将线程要运行的代码定义其中。
3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。

 

如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以在继承Thread。怎么办呢？

Java给我们提供了一个规则。Runnable接口。
如果自定义类不继承Thread，也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。
这样多线程也可以帮助该类运行。
这样的操作有一个好处：避免了单继承的局限性。

创建线程的第二种方式：实现Runnable接口。

步骤：
1，定义了实现Runnable接口。
2，覆盖接口的run方法。将多线程要运行的代码存入其中。
3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
 为什么要传递？因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象
 传递给Thread。让Thread线程去使用该对象调用其run方法。
4，调用Thread对象的start方法。开启线程。

动手写代码。

两种方式的特点：
实现方式，因为避免了单继承的局限性，所以创建线程建议使用第二种方式。

##############################
#第一重点：创建线程的两种方式#
##############################

 

作为了解：
线程的状态。
1，被创建。
2，运行。
3，冻结。
4，消亡。

其实还有一种特殊的状态：临时状态。

该临时状态的特点：
具备了执行资格，但不具备执行权。

冻结状态的特点：
放弃了执行资格。

 

多线程具备随机性。因为是由cpu不断的快速切换造成的。

就有可能会产生多线程的安全问题。

问题的产生的原因：
几个关键点：
1，多线程代码中有操作共享数据。
2，多条语句操作该共享数据。

当具备两个关键点时，
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。
就会发生数据错误。

解决方法：
当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。

Java就对这种解决方式提供了专业的代码。
同步
同步的原理：就是将部分操作功能数据的代码进行加锁。

示例：火车上的卫生间。

同步的表现形式：
1，同步代码块。
2，同步函数。
两者有什么不同：
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。

注意：对于static的同步函数，使用的锁不是this。是 类名.class 是该类的字节码文件对象。
 涉及到了单例设计模式的懒汉式。

同步的好处：解决了线程的安全问题。

弊端：
 较为消耗资源。
 同步嵌套后，容易死锁。

要记住：同步使用的前提：
 1，必须是两个或者两个以上的线程。
 2，必须是多个线程使用同一个锁。
 这是才可以称为这些线程被同步了。

死锁代码一定会写。但开发时一定注意避免。

 

##############################
#第二重点：同步的所有特性    #
##############################

/*

class Thread
{
 private Runnable target;

 Thread()
 {
 }
 Thread(Runnable target)
 {
  this.target = target;
 }

 public void run()
 {
  if(target!=null)
   target.run();
 }
}

class Test implements Runnable
{
 public void run()
 {}
}

main()
{
 Test q = new Test();
 Thread t = new Thread(q);
}

class Demo extends Thread
{
 public void run()
 {
 }
}
class 
{
 public static void main(String[] args)
 {
  System.out.println("Hello World!");
 }
}
*/

三：解决安全问题，等待唤醒机制，代码优化。

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

*/
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(Exception e){}
  this.name = name;
  
  this.sex = sex;
  flag = true;
  this.notify();
 }
 public synchronized void out()
 {
  if(!flag)
   try{this.wait();}catch(Exception 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","man");    
   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  InputOutputDemo2
{
 public static void main(String[] args)
 {
  Res r = new Res();

  new Thread(new Input(r)).start();
  new Thread(new Output(r)).start();
  /*
  Input in = new Input(r);
  Output out = new Output(r);

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

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

 

四：线程间通信-生产消费者。

 

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(pro);
  Thread t3 = new Thread(con);
  Thread t4 = new Thread(con);

  t1.start();
  t2.start();
  t3.start();
  t4.start();

 }
}

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

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

*/

class Resource
{
 private String name;
 private int count = 1;
 private boolean flag = false;
   //  t1    t2
 public synchronized void set(String name)
 {
  while(flag)
   try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
  this.name = name+"--"+count++;

  System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
  flag = true;
  this.notifyAll();
 }

 //  t3   t4 
 public synchronized void out()
 {
  while(!flag)
   try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
  System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
  flag = false;
  this.notifyAll();
 }
}

class Producer implements Runnable
{
 private Resource res;

 Producer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  while(true)
  {
   res.set("+商品+");
  }
 }
}

class Consumer implements Runnable
{
 private Resource res;

 Consumer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  while(true)
  {
   res.out();
  }
 }
}

五：多线程(线程间通信-生产者消费者JDK5.0升级版)

import java.util.concurrent.locks.*;

class ProducerConsumerDemo2
{
 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(pro);
  Thread t3 = new Thread(con);
  Thread t4 = new Thread(con);

  t1.start();
  t2.start();
  t3.start();
  t4.start();

 }
}

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

Lock:替代了Synchronized
 lock
 unlock
 newCondition()

Condition：替代了Object wait notify notifyAll
 await();
 signal();
 signalAll();
*/
class Resource
{
 private String name;
 private int count = 1;
 private boolean flag = false;
   //  t1    t2
 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();//t1,t2
   this.name = name+"--"+count++;

   System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
   flag = true;
   condition_con.signal();
  }
  finally
  {
   lock.unlock();//释放锁的动作一定要执行。
  }
 }

 //  t3   t4 
 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.signal();
  }
  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，定义循环结束标记。
  a,因为线程运行代码一般都是循环，只要控制了循环即可。

 2，使用interupt(中断)方法。
  b,该方法是结束线程的冻结状态，使线程回到运行状态中来。

 注意：stop方法已经过时不再使用。

/*
stop方法已经过时。

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

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

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

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

Thread类提供该方法 interrupt();

 

*/
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.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");
 }
}

七：多线程-join方法。

1，
/*
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);
   Thread.yield();
  }
 }
}

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.setPriority(Thread.MAX_PRIORITY);

  t2.start();

  //t1.join();

  for(int x=0; x<80; x++)
  {
   //System.out.println("main....."+x);
  }
  System.out.println("over");
 }
}

八：多线程-优先级&yield方法。

class MyThread extends Thread{
 public void run(){
  try {
   Thread.currentThread().sleep(3000);
  } catch (InterruptedException e) {
  }
  System.out.println("MyThread running");
 }
}

 

public class ThreadTest{
 public static void main(String argv[]) {
  MyThread t = new MyThread();
  t.run();
  t.start();
  System.out.println("Thread Test");
   }
}

/*
代码分析过程：

MyThread t = new MyThread();
创建了一个线程。

t.run();
调用MyThread对象的run方法。
这是只有一个线程在运行就是主线程。
当主线程执行到了run方法中的sleep(3000);时。
这是主线程处于冻结状态。程序并没有任何执行。
当3秒过后，主线程打印了  MyThread running。 run方法执行结束。

t.start();
开启了t线程。
有两种可能情况。
第一种，主线程在只执行了t.start()后，还具有执行权，继续往下执行，
打印了Thread Test。主线程结束。
t线程获取执行权，调用自己的run方法。然后执行的sleep(3000);冻结3秒。
3秒后，打印MyThread running t线程结束，整个程序结束。

第二种情况：
主线程执行到t.start();开启了t线程，t线程就直接获取到了执行权。
就调用自己的run方法。
指定到sleep(3000).t线程冻结3秒，这是t线程就是释放了执行权。
那么主线程开始执行打印了Thread Test，主线程结束。
等到3秒后，t线程打印MyThread running ，然后t线程结束。
程序结束。

 

 

 

*/

 

2，
class test_parent
{
 int x = 5;
 int y = 10;
 void set_value(int a, int b)
 {
  x = a;
  y = b;
 }
 int get_1()
 {
  return this.x + this.y;
 }
 int get_2()
 {
  return x - y;
 }
}

class test_4 extends test_parent
{
 int y;
 test_4(int a)
 {
  y = a;
 }
 void set_value(int a, int b)
 {
  x = a;
  y = b;
 }
 int get_2()
 {
  return y;
 }
}

class  Test2
{
 public static void main(String[] args)
 {
  test_4  a1=new test_4(1);
  int x = a1.get_1();
  System.out.println("x="+x);
 }
}
/*

如果用下面几种不同的方法加载类，写出要求的结果：
    (3) 用  test_4  a1=new test_4(1) 后；a1.get_1()的内容为_____ 。
 (4) 用  test_4  a1=new test_4(－1) ；a1.set _value(5,5) 后；a1.get_2()的内容为
_____。

*/

 

 

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