黑马程序员_06 多线程

              

       ---------------------- ASP.Net+Android+IO开发S、 .Net培训、期待与您交流！ ----------------------     

 

 

                      

                                          多线程

一：进程与线程：
                进程：1：一个进程就是一个执行中的程序，而每一个进程都有自己独立的

                            一块内存空间。
                           2：进程是程序的一次执行过程，是系统运行程序的基本单位。
                线程：1：在java中，程序通过流控制来执行程序流，程序中单个顺序的流

                            控制称为线程。
                           2：多线程指的是在单个进程中可以同时运行多个不同线程。
二：多线程的两种实现方式： 
      （1）通过继承Thread类实现多线程。
                   class类名称extendsThread         //从Thread类扩展出子类
                  {
                            属性...
                            方法...
                            修饰符 run（）                  //覆写Thread类中run（）方法
                            {
                               多线程运行的程序
                             }
                    }    
       public static void main(String[]args)
                  {
                        new类名称（）·start（）；//建立线程，并开启。
                   }
       （2）   通过实现Runnable接口实现多线程。
                         class Demo(类名称)implements Runnable              //实现Runnable接口
                           {
                                  属性...
                                  方法...
                                  修饰符 run（）                     //覆盖Thread类中run（）方法
                                  {
                                         多线程执行程序；
                                    }
                             }     
                            public static void main(String[])
                            {
                                Demo d=new Demo();       //实例化Demo类
                                 new  Thread(d).start();      //建立并开启线程
                             }
三：实现Runnable相对于继承的优势;
                1：适合多个程序代码处理同一资源的情况。
                2：可以避免java单继承带来的局限性。
                3：增强程序的健壮性，代码能被多个线程共享。
四：线程五种状态：
     ①NEW：这种情况指的是，通过New关键字创建了Thread类（或其子类）

         的对象
     ②RUNNABLE：这种情况指的是Thread类的对象调用了start()方法，这时

       的线程就等待时间片轮转到自己这，以便获得CPU；第二种情况是线程在处于

       RUNNABLE状态时并没有运行完自己的run方法，时间片用完之后回到

        RUNNABLE状态；还有种情况就是处于BLOCKED状态的线程结束了当前的

       BLOCKED状态之后重新回到RUNNABLE状态。
     ③RUNNING：这时的线程指的是获得CPU的RUNNABLE线程，RUNNING状态

      是所有线程都希望获得的状态。

      ④DEAD：处于RUNNING状态的线程，在执行完run方法之后，就变成了DEAD

         状态了。

       ⑤BLOCKED：这种状态指的是处于RUNNING状态的线程，出于某种原因，比

           如调用了sleep方法、等待用户输入等而让出当前的CPU给其他的线程。
五:获取线程对象及名称
     获取线程对象  Thread.currentThread（）；
     获取线程名称  Thread.currentThread（）.getName（）；
     设置线程名称   Thread.currentThread（）.setName（）；
六：线程的同步
      在多线程编程里面，一些敏感数据不允许被多个线程同时访问，此时就使用同步

       访问技术，保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。

       在Java里面，通过synchronized 进行同步的保证。
      
        class MyTest
             {
                   static final Object lock = new Object();//锁

                   public static synchronized void test(){ // 同步的方法　}

                   public void test2(){

                   synchronized(lock){ // 同步代码块　}　}

              }
             注意：同步函数使用的锁是this，静态同步函数使用的是class对象。
七：线程间通信，jdk5.0升级版实例
        
              import java.util.concurrent.locks.*;
              public class Ren
             {
                private String name;
                private int age;
                private boolean bo=false;//标记
                private int count=0;//计数器

     private Lock lk=new ReentrantLock();//获取锁
                private Condition cn=lk.newCondition();
                private Condition co=lk.newCondition();
                public void set(String name,int age)throws Exception
                { 
                       try
                      {
                            lk.lock();//加锁
                             while(bo)//判断标记
                            {
                               cn.await();//等待
                             }
                           this.name=name+".."+count++;
                           this.age=age;
                           System.out.println(Thread.currentThread().getName());
                            bo=true;//修改标记
                            co.signal();//唤醒对方
                        }
                      finally
                       {
                          lk.unlock();//解锁
                        }

       }
                    public void get()throws Exception
                    {
                            try
                           {
                               lk.lock();//上锁
                               while(!bo)//标记
                                 {
                                     co.await();//等待
                                 }
                                 System.out.println(Thread.currentThread().getName());
                                 bo=false;//修改标记
                                 cn.signal();//唤醒对方
                                 }
                                 finally
                                 {
                                   lk.unlock();//解锁
                                 }
                             }
                       }
八：死锁
死锁指的是由于两个或多个执行单元之间相互等待对方结束而引起阻塞的情况。例如：

            一个线程T1获得了对资源R1的访问权。

            一个线程T2获得了对资源R2的访问权。

            T1请求对R2的访问权但是由于此权力被T2所占而不得不等待。

            T2请求对R1的访问权但是由于此权力被T1所占而不得不等待。

            T1和T2将永远维持等待状态，此时我们陷入了死锁的处境！这种问题比你所遇

             到的大多数的bug都要隐秘，针对此问题主要有三种解决方案：

            （1）在同一时刻不允许一个线程访问多个资源。

             （2）为资源访问权的获取定义一个关系顺序。换句话说，当一个线程已经获得

                  了R1的访问权后， 将无法获得R2的访问权。当然，访问权的释放必须遵循

                  相反的顺序。

             （3）为所有访问资源的请求系统地定义一个最大等待时间（超时时间），并妥

                 善处理请求失败的 情况。

--------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------