多线程————线程通信

线程优先级

cpu先执行优先级高的线程的对象任务， setPriority方法可以设置线程的优先级

线程优先级具有继承性，也就是说A线程启动B线程，二者优先级一样，同样main主线程启动线程A，main和A的优先级也是一样的

public static void main(String[] args) {

                   System.out.println("main thread begin priority="

                                     + Thread.currentThread().getPriority());

                   Thread.currentThread().setPriority(6);

                   System.out.println("main thread end   priority="

                                     + Thread.currentThread().getPriority());

                   MyThread1 thread1 = new MyThread1();

                   thread1.start();

         }

         class MyThread1 extends Thread {

                   @Override

                   public void run() {

                            System.out.println("MyThread1 run priority=" + this.getPriority());

                            MyThread2 thread2 = new MyThread2();

                            thread2.start();

                   }

守护线程

线程有两种一种是用户线程，一种是守护线程

垃圾回收线程是典型的守护线程，当jvm中还有非守护线程，守护线程就一直还在，知道非守护线程不存在了，守护线程才销毁

线程通信

使用Condition控制线程通信

      jdk1.5中，提供了多线程的升级解决方案为：

     （1）将同步synchronized替换为显式的Lock操作；

     （2）将Object类中的wait(), notify(),notifyAll()替换成了Condition对象，该对象可以通过Lock锁对象获取;

     （3）一个Lock对象上可以绑定多个Condition对象，这样实现了本方线程只唤醒对方线程，而jdk1.5之前，一个同步只能有一个锁，不同的同步只能用锁来区分，且锁嵌套时容易死锁。

    class Resource{ 

        private String name; 

        private int count=1; 

        private boolean flag=false; 

        private Lock lock = new ReentrantLock();/*Lock是一个接口，ReentrantLock是该接口的一个直接子类。*/ 

        private Condition condition_pro=lock.newCondition(); /*创建代表生产者方面的Condition对象*/ 

        private Condition condition_con=lock.newCondition(); /*使用同一个锁，创建代表消费者方面的Condition对象*/ 

          

        public void set(String name){ 

            lock.lock();//锁住此语句与lock.unlock()之间的代码 

            try{ 

                while(flag) 

                    condition_pro.await(); //生产者线程在conndition_pro对象上等待 

                this.name=name+"---"+count++; 

                System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name); 

                flag=true; 

                 condition_con.signalAll(); 

            } 

            finally{ 

                lock.unlock(); //unlock()要放在finally块中。 

            } 

        } 

        public void out(){ 

            lock.lock(); //锁住此语句与lock.unlock()之间的代码 

            try{ 

                while(!flag) 

                    condition_con.await(); //消费者线程在conndition_con对象上等待 

            System.out.println(Thread.currentThread().getName()+"...消费者..."+this.name); 

            flag=false; 

            condition_pro.signqlAll(); /*唤醒所有在condition_pro对象下等待的线程，也就是唤醒所有生产者线程*/ 

            } 

            finally{ 

                lock.unlock(); 

            } 

        } 

    } 

3、使用阻塞队列（BlockingQueue）控制线程通信

       BlockingQueue是一个接口，也是Queue的子接口。BlockingQueue具有一个特征：当生产者线程试图向BlockingQueue中放入元素时，如果该队列已满，则线程被阻塞；但消费者线程试图从BlockingQueue中取出元素时，如果队列已空，则该线程阻塞。程序的两个线程通过交替向BlockingQueue中放入元素、取出元素，即可很好地控制线程的通信。

BlockingQueue提供如下两个支持阻塞的方法：

  （1）put(E e)：尝试把Eu元素放如BlockingQueue中，如果该队列的元素已满，则阻塞该线程。

  （2）take（）：尝试从BlockingQueue的头部取出元素，如果该队列的元素已空，则阻塞该线程。

wait()方法

　　wait()方法使得当前线程必须要等待，等到另外一个线程调用notify()或者notifyAll()方法。

　　当前的线程必须拥有当前对象的monitor，也即lock，就是锁。

　　线程调用wait()方法，释放它对锁的拥有权，然后等待另外的线程来通知它（通知的方式是notify()或者notifyAll()方法），这样它才能重新获得锁的拥有权和恢复执行。

　　要确保调用wait()方法的时候拥有锁，即，wait()方法的调用必须放在synchronized方法或synchronized块中。

　　一个小比较：

　　当线程调用了wait()方法时，它会释放掉对象的锁。

　　另一个会导致线程暂停的方法：Thread.sleep()，它会导致线程睡眠指定的毫秒数，但线程在睡眠的过程中是不会释放掉对象的锁的。

notify()方法

　　notify()方法会唤醒一个等待当前对象的锁的线程。

　　如果多个线程在等待，它们中的一个将会选择被唤醒。这种选择是随意的，和具体实现有关。（线程等待一个对象的锁是由于调用了wait方法中的一个）。

　　被唤醒的线程是不能被执行的，需要等到当前线程放弃这个对象的锁。

　　被唤醒的线程将和其他线程以通常的方式进行竞争，来获得对象的锁。也就是说，被唤醒的线程并没有什么优先权，也没有什么劣势，对象的下一个线程还是需要通过一般性的竞争。

　　notify()方法应该是被拥有对象的锁的线程所调用。

　　（This method should only be called by a thread that is the owner of this object's monitor.）

　　换句话说，和wait()方法一样，notify方法调用必须放在synchronized方法或synchronized块中。

　　wait()和notify()方法要求在调用时线程已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或synchronized块中。

　　一个线程变为一个对象的锁的拥有者是通过下列三种方法：

　　1.执行这个对象的synchronized实例方法。

　　2.执行这个对象的synchronized语句块。这个语句块锁的是这个对象。

　　3.对于Class类的对象，执行那个类的synchronized、static方法。

程序实例

　　利用两个线程，对一个整形成员变量进行变化，一个对其增加，一个对其减少，利用线程间的通信，实现该整形变量0101这样交替的变更。

public class NumberHolder

{

    private int number;

    public synchronized void increase()

    {

        if (0 != number)

        {

            try

            {

                wait();

            }

            catch (InterruptedException e)

            {

                e.printStackTrace();

            }

        }

        // 能执行到这里说明已经被唤醒

        // 并且number为0

        number++;

        System.out.println(number);

        // 通知在等待的线程

        notify();

    }

    public synchronized void decrease()

    {

        if (0 == number)

        {

            try

            {

                wait();

            }

            catch (InterruptedException e)

            {

                e.printStackTrace();

            }

        }

        // 能执行到这里说明已经被唤醒

        // 并且number不为0

        number--;

        System.out.println(number);

        notify();

    }

}

public class IncreaseThread extends Thread

{

    private NumberHolder numberHolder;

    public IncreaseThread(NumberHolder numberHolder)

    {

        this.numberHolder = numberHolder;

    }

    @Override

    public void run()

    {

        for (int i = 0; i < 20; ++i)

        {

            // 进行一定的延时

            try

            {

                Thread.sleep((long) Math.random() * 1000);

            }

            catch (InterruptedException e)

            {

                e.printStackTrace();

            }

            // 进行增加操作

            numberHolder.increase();

        }

    }

}

public class DecreaseThread extends Thread

{

    private NumberHolder numberHolder;

    public DecreaseThread(NumberHolder numberHolder)

    {

        this.numberHolder = numberHolder;

    }

    @Override

    public void run()

    {

        for (int i = 0; i < 20; ++i)

        {

            // 进行一定的延时

            try

            {

                Thread.sleep((long) Math.random() * 1000);

            }

            catch (InterruptedException e)

            {

                e.printStackTrace();

            }

            // 进行减少操作

            numberHolder.decrease();

        }

    }

}

public class NumberTest

{

    public static void main(String[] args)

    {

        NumberHolder numberHolder = new NumberHolder();

       

        Thread t1 = new IncreaseThread(numberHolder);

        Thread t2 = new DecreaseThread(numberHolder);

               

        t1.start();

        t2.start();

    }

}