黑马程序员---多线程（二）

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

16、interrupt:

       voidinterrupt() 中断线程:

              中断状态将被清除，它还将收到一个 InterruptedException

17、守护线程(后台线程)

       setDaemon(booleanon):将该线程标记为守护线程或者用户线程。

                            当主线程结束，守护线程自动结束，比如圣斗士星矢里面的守护雅典娜，

                            在多线程里面主线程就是雅典娜，守护线程就是圣斗士，主线程结束了，

                            守护线程则自动结束。

       当正在运行的线程都是守护线程时，java虚拟机jvm退出；所以该方法必须在启动线程前调用；

 

       守护线程的特点：

              守护线程开启后和前台线程共同抢夺cpu的执行权，开启、运行两者都没区别，

              但结束时有区别，当所有前台线程都结束后，守护线程会自动结束。

 

jvm中的多线程体现。

              主线程，垃圾回收线程，自定义线程。以及他们运行的代码的位置。

      

18、多线程join方法：

       voidjoin() 等待该线程终止。

       voidjoin(long millis)  等待该线程终止的时间最长为 millis 毫秒。

              throwsInterruptedException        

       特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行

       作用: join可以用来临时加入线程执行；

19、多线程优先级：yield()方法

       yield():暂停当前正在执行的线程对象，并执行其他线程

       setPriority(intnewPriority):更改线程优先级

       intgetPriority() 返回线程的优先级。

       StringtoString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

          

       (1)MAX_PRIORITY:最高优先级(10级)

       (1)Min_PRIORITY:最低优先级(1级)

       (1)Morm_PRIORITY:默认优先级(5级)

 

class Test implements Runnable{

       privateboolean flag;

       Test(booleanflag){ this.flag = flag;}

       publicvoid run(){

              if(flag){

                     while(true)

                            synchronized(MyLock.locka){

                                   System.out.println(Thread.currentThread().getName()+"..if   locka....");

                                   synchronized(MyLock.lockb) {

                                          System.out.println(Thread.currentThread().getName()+"..if                                                                                         lockb....");

                                   }}}

              else{

                     while(true)                  

                            synchronized(MyLock.lockb){

                                   System.out.println(Thread.currentThread().getName()+"..else         lockb....");

                                   synchronized(MyLock.locka){

                                          System.out.println(Thread.currentThread().getName()+"..else         locka....");

                                   }}}}}

class MyLock{

       publicstatic final Object locka = new Object();

       publicstatic final Object lockb = new Object();

}

class DeadLockTest {

       publicstatic void main(String[] args) {

              Testa = new Test(true);

              Testb = new Test(false);

              Threadt1 = new Thread(a);

              Threadt2 = new Thread(b);

              t1.start();

              t2.start();

       }}

20、停止线程：

       stop方法已经过时，如何停止线程？

              停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？

              开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。

              特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。

              为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；

              当没有指定的方式让冻结线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态

 

21、多线程的单例设计模式：保证某个类中内存中只有一个对象

       (1)饿汉式:

              classSingle

              {

                     privateSingle(){}//将构造函数私有化，不让别的类建立该类对象

                     privatestatic final Single s=new Single();//自己建立一个对象

                     publicstatic Single getInstance()//提供一个公共访问方式

                     {

                            returns;

                     }

              }

       (2)懒汉式：

              classSingle

              {

                     private Single(){}

                     privatestatic Single s;

                     publicstatic Single getInstance()

                     {

                            if(s==null)

                                   s=newSingle();

                            returns;

                     }

              }

       饿汉式和懒汉式的区别：

             

              饿汉式是类一加载进内存就创建好了对象；

              懒汉式则是类加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。 

             

              懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题（面试通常是懒汉式）

              可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，

              所以可以加双重判断来提高程序效率。

              如将上述懒汉式的Instance函数改成同步：

              publicstatic Single getInstance()

              {

                     if(s==null)

                     {

                            synchronized(Single.class)

                            {

                                   if(s==null)

                                          s=new Single();

                            }

                     }

                     returns;

              }

22、线程间的通信。等待/唤醒机制。

       |--概念：多个线程，不同任务，处理同一资源。

       |--等待唤醒机制。使用了锁上的 wait notifynotifyAll.  

       |--生产者/消费者的问题。并多生产和多消费的问题。  while判断标记。用notifyAll唤醒对方。 

       |--JDK1.5以后出现了更好的方案，

              Lock接口替代了synchronized 

              Condition接口替代了Object中的监视方法，并将监视器方法封装成了Condition

              和以前不同的是，以前一个锁上只能有一组监视器方法。现在，一个Lock锁上可以多组监视器方法对象。

              可以实现一组负责生产者，一组负责消费者。

       |--wait和sleep的区别。