黑马程序员——java基础---多线程(二)

　　  线程间的通信：简单来说，就是多个线程在操作同一资源，但操作的动作不同。

　　试想一下，对于同一个资源做不同的操作，这势必会在操作的过程中产生矛盾。为了避免这种情况的发生，就需要用的synchronized来保证，每次对共享资源的操作，只能是一条线程在进行。在用到同步的时候，就会因需求问题用到wait()、notify()、notifyAll()这三个方法。

　　wait()方法：作用是使调用线程自动释放CPU使用权，从而使线程本身进入线程池继续等待。

　　notify()方法：由运行的线程唤醒线程池中排在最前面的等待线程，使该线程具有使用CPU的资格。

　　notifyAll()方法：由运行的线程唤醒线程池中的所有等待线程。

　　因为三个方法都需以对持有(锁)监视器的对象操作，也就使他们只能在同步中使用，因为只有同步中才会出现锁这个概念。而通过查阅API，我们很容易就发现这三个方法都被定义在Object类当中，那么这些操作锁的方法为什么会被定义在Object类中呢？我们可以这样理解，同步中对于锁的标志位可以是任意的特有对象，而这三个方法都是操作锁的，也就是说他们可以操作任何对象，Java中能操作任何对象的类也只有Object类了。

　　虽然有这些方法来使同步机制更加完善，但是对于某些情况同步机制并不能完美的完成相应的功能。

　　针对以下代码：

*
 * 生产者消费者问题
 */
public 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 t3 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//定义共享的资源类
class Resource{
    private String name;
    private int count = 1;
    private boolean flag = false;

    public synchronized void set(String name){
        while(flag)
            try{
                this.wait();
            }catch(Exception e){

            }
        this.name = name+"--"+count++;
        System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
        flag = true;
        this.notifyAll();
    }
    public synchronized void out(){
        while(!flag)
            try{
                wait();
            }catch(Exception e){
            }
        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();
        }
    }
}

　　在这个类中虽然可以初步满足生产者消费者这一功能需求，但我们可以发现在代码中我们用了notifyAll()这个方法，这个方法每运行一次将会把所有的等待状态的线程全部唤醒，这会给计算机带来很大的耗费，这种情况显然并不是我们所期望的。

　  针对上述问题，官方在JDK1.5版本中进行了升级：

  * 引进了Lock接口从而替代了synchronized 
  * 用Condition 替代了 Object监视器方法
  这样做的好处就是：一定程度上简化了同步代码的编写；一个Condition对象可以对不同锁进行操作，而且可以根据需求对特定的线程进行唤醒。而同时也要注意：一定要在对应的程序代码尾部执行释放锁的操作。
  下面是通过运用Lock和Condition改进后的代码：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/*
 * 生产者消费者问题
 */
public class ProducerConsumerDemo2{
    public static void main(String[] args){
        Resource2 r = new Resource2();
        Producer2 pro = new Producer2(r);
        Consumer2 con = new Consumer2(r);

        Thread t1 = new Thread(pro);
        Thread t3 = new Thread(pro);
        Thread t2 = new Thread(con);
        Thread t4 = new Thread(con);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}
//定义共有的资源
class Resource2{
     private String name;
     private int count = 1;
     private boolean flag = false;
    
     private ReentrantLock lock = new ReentrantLock();
     Condition c_pro = lock.newCondition();
     Condition c_con = lock.newCondition();

    public void set(String name) throws InterruptedException{
        lock.lock();
        try{
            while(flag)
                    c_pro.await();
            this.name = name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
            flag = true;
            c_con.signal();
        }finally{
            lock.unlock();
        }
    }
    public void out() throws InterruptedException{
        lock.lock();
        try{
            while(!flag)
                c_con.await();
            System.out.println(Thread.currentThread().getName()+"-----消费者-----"+this.name);
            flag = false;
            c_pro.signal();
        }finally{
            lock.unlock();
        }
    }
}
//定义生产者
class Producer2 implements Runnable{
    private Resource2 res;
    Producer2(Resource2 r){
        this.res = r;
    }
    public void run(){
        while(true){
            try {
                res.set("+商品+");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}
//定义消费者
class Consumer2 implements Runnable{
    private Resource2 res;
    Consumer2(Resource2 r){
        this.res = r;
    }
    public void run(){
        while(true){
            try {
                res.out();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

 

　接下来是关于线程的停止：
　　　1、正常的情况是，等待线程运行完，自动释放CPU占用权。这种方式也是最为安全的。
　　   2、多线程中常用循环控制语句，我们可以通过设置标志位，来使线程在不满足条件的情况下自动释放CPU资源，停止运行。
　　　3、对于占有资源但却因为某种原因进入冻结的线程，我们可以使用interrupt()方法来打断其状态，进而使之可以正常运行释放资源。

　设置守护进程的方法：通过调用SetDaemon()方法，可以把对应进程设置成守护进程或者是用户进程。

　 join()方法：作用是长期占有CPU使用权。原理是：当A线程执行到了B线程的join方法时，A就会等待，等B线程执行完，A才会执行。Join可以用来临时加入线程执行。
   代码示例：

class Demo implements Runnable{
    public void run(){
        for(int x=0; x<20; x++){
            System.out.println(Thread.currentThread().getName()+"---"+x);
        }
    }
}
public class JoinTest {
    public static void main(String[] args) throws InterruptedException {
        Demo d = new Demo();
        Thread t1 = new Thread(d);
        Thread t2 = new Thread(d);
        
        t1.start();
        t1.join();
        t2.start();
        
        for(int x=0; x<30; x++){
            System.out.println("main--"+x);
        }
        System.out.println("over");
    }
}

 

  执行结果：

Thread-0---0
Thread-0---1
Thread-0---2
Thread-0---3
Thread-0---4
Thread-0---5
Thread-0---6
Thread-0---7
Thread-0---8
Thread-0---9
Thread-0---10
Thread-0---11
Thread-0---12
Thread-0---13
Thread-0---14
Thread-0---15
Thread-0---16
Thread-0---17
Thread-0---18
Thread-0---19
main--0
Thread-1---0
main--1
Thread-1---1
Thread-1---2
Thread-1---3
Thread-1---4
Thread-1---5
Thread-1---6
Thread-1---7
main--2
Thread-1---8
Thread-1---9
main--3
Thread-1---10
main--4
Thread-1---11
Thread-1---12
Thread-1---13
Thread-1---14
Thread-1---15
Thread-1---16
main--5
main--6
main--7
main--8
main--9
main--10
main--11
main--12
main--13
main--14
main--15
main--16
main--17
Thread-1---17
main--18
Thread-1---18
main--19
Thread-1---19
main--20
main--21
main--22
main--23
main--24
main--25
main--26
main--27
main--28
main--29
over

　　我们可以发现只有当线程t1执行完以后，main线程才会和t2线程继续强度CPU的使用权，进而相继输出。所以可以理解为join()方法是线程具有了长期占有CPU的资格。

　   关于线程优先级的知识：

　　　　 1、线程的优先级设置范围为（1-10）；

　　　    2、线程默认的优先级是5；

           3、我们可以通过SetPriority(1-10)来对线程的优先级进行设置。

　　　  4、因为相邻的优先级效果差别很小，说以一般提倡对优先级设置一下几个值：Thread.MAX_PRIORITY 10 ；Thread.MIN_PRIORITY 1；Thread.NORM_PRIORITY 5

　  yield()方法：暂停当前正在执行的线程，转而去执行其它线程。　

开发中应用：保证以下三个代码同时运行。
案例代码：

new Thread(){
      for(int x=0;x<100;x++){
         sop(Thread.currentThread().getName())
      }
}.start();

      for(int x=0;x<100;x++){
         sop(Thread.currentThread().getName())
      }

Runnable r=new Runnable(){
   public voud run(){
      for(int x=0;x<100;x++){
         sop(Thread.currentThread().getName())
      }
   }
};

new Thread(r).start();