黑马程序员--多线程

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

 

一.多线程(Thread)

   1.定义：线程是进程中的一个独立控制单元，线程控制着进程的执行；而进程是一个正在执行中的程序，每一个程序都有一个执行顺序，该顺序是一个执行路径。通俗说多线程就是多个线程在抢占CPU的执行权

   2.特点：随机性(每个线程随机执行)、执行顺序由CPU决定

   3. 线程的状态：被创建(start())、运行、临时状态(阻塞，具备执行资格但无执行权)、冻结(放弃了执行权，sleep()，wait())、死亡(run方法结束，stop())

   4.线程同步的前提：有两个或两个以上的线程、使用的是同一个锁

   5. java的线程：java虚拟机在运行时会启动一个java.exe的进程，这个线程主要负责java程序的执行，称为java主线程，其实不然，java虚拟机在启动时，会自动开启两个线程，一个是主线程，还有一个是垃圾回收的线程，所以java线程也是多线程。

 

二.自定义线程

    1.自定义线程的两种方法：

         ①自定义一个类，让其继承Thread类，覆盖run方法，调用自定义类对象的start方法，开启线程

               class MyThread extends Thread{  //继承Thread类并复写run方法

                        public void run(){  //run方法内的代码可以自定义，在此是输出当前线程名和变量的值

                                for(int i=0;i<100;i++){

                                        System.out.println("currentThread=="+Thread.currentThread().getName()+i);

                                }

                        }

               }

             main： //主函数

                 MyThread  mt = new  MyThread();

                 mt.start(); //开启线程，自动调用复写父类的run方法

                 MyThread  mt2 = new  MyThread();

                 mt2.start(); 

           结论：每次运行的结果都不一样，这是因为CPU每次分配给线程的执行权不同，进而说明，多线程的随机性

         ②自定义一个类，让其实现Runnable接口，覆盖run方法

               class MyThreadimplements Runnable{//实现Runnable接口并复写run方法

                   public void run(){//run方法内的代码可以自定义，在此是输出当前线程名和变量的值

                          for(int i=0;i<100;i++){

                                        System.out.println("currentThread=="+Thread.currentThread().getName()+i);

                           }

                   }

               }

         main：//主函数

              MyThread mt = new MyThread();

             Thread  t1  = new  Thread(mt);//创建线程，将自定义线程实例作为参数传入线程中

              Thread  t2 = new  Thread(mt); 

               t1.start();//线程开启

               t2.start();

       小结：这是创建线程常用的方式，它的优点在于避免了单继承的局限性

 

三.多线程安全问题

   1.产生的问题：数据不合法

   2.产生问题的原因：操作多条语句时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与共享数据，导致共享数据出错。

  3.解决方法：使用锁机制，将要操作的语句锁起来，使只有一个线程在操作，而其他线程进不来

  4.解决方式：同步代码块

             synchronized(锁){

                //要同步或要操作的代码块，其他无关代码不该放在此

             }

  5.同步函数：将synchronized放在非静态函数上，使用的锁是this

             public synchronized void show(){

                 //该函数内部只能是需要被同步的代码

 

             }

             public void run(){

                  show();//使用的锁是this

             }

  6.静态同步函数：将synchronized放在静态函数上，使用的锁是类名.class，即字节码文件对象

            public static synchronized void show(){

                 //该函数内部只能是需要被同步的代码

             }

            public void run(){

                  show();//使用的锁是类名.class

             }

 

四.多线程--单例设计模式

   1.懒汉式：

        class MySingle{

             private MySingle(){}

             ptivate static MySingle ms=null;

             public static MySingle getInstance(){

                        if(ms==null){

                               synchronized(MySingle.class){

                                    if(ms==null){

                                         ms = new MySingle();

                                    }

                               }

                        }

                 return ms;

             }

        }

   2.死锁：同步中嵌套同步，会导致程序静止不动

 

五.线程间通信

    1.定义：多个线程在操作一个资源，操作的动作不同，可以看做是生产者和消费者，一个线程负责生产，一个线程负责消费

    2.线程安全问题：使用同步，如果同步还出现问题，看线程同步的前提：①多个线程操作一个资源 ②同一个锁

    3.等待唤醒机制：在同一个锁中，操作线程，操作线程的方法有：wait()、notify()、notifyAll().

    4.生产者消费者：

          1个生产者，1个小费者的情况

          .....

          if(flag){

               try{

                     this.wait();

               }catch(Exception e){

                     e.toString();

              }

          }

          //相应操作

          flag=false;

          this.notify();

          ........

          多个生产者，多个消费者，将if该为while、notify()改成notifyAll()即可

     5.JDK5.0升级版的线程： lock替代了synchronized，Condition接口的系列方法替代了wait()、notify()、notifyAll()

                .......

                private Lock lock=new Reentrantlock();

                private Condition condition_con =lock.newCondition();

                private Condition condition_pro = lock.newCondition();

                lock.lock();//上锁

                condition_con.await();//等待线程   

                lock.signal();//唤醒线程

                lock.unlock();//解锁

    6.JDK5.0后，提供了显示的锁机制，唤醒机制，而且Condition对象可以实例多个，很实用

    7.停止线程：只有一种方法，使run方法结束

    8.守护线程：后台线程，setDaemon(true);

    9.加入线程：使用join方法加入

    10.优先级、yield方法：优先级分为1-10级，默认为5级，等级越高抢夺CPU的执行率越大；Thread.yield();

 

六.线程开发常用

1.main：

     new Thread(){

        public void run(){

           //功能代码

        }

     }.start(); //开启一个线程的简洁版

2.main：

     Runnable  r = new Runnable(){

            public void run(){

               //功能代码

            }

     };

    new Thread(r).start();//同样可以开启一个线程

 

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