黑马程序员--多线程

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

一、概述

进程：是一个正在执行的程序，每一个进程都有一个执行顺序，该顺序是一个执行路径，或叫一个控制单元

线程：就是进程中的一个独立的控制单元

线程在控制着进程的执行，一个进程中至少有一个线程

JVM启动的时候会有一个进程java.exe,该进程中至少有一个进程负责java程序的执行，而且这个线程运行的代码存在于main方法中，该线程陈为主线程

扩展：其实更细节说明JVM，JVM启动不止一个线程，还有负责垃圾回收机制的线程

1.如何在自定义的代码中，自定义一个线程呢？

通过api的查找，java已经提供了对线程这类事物的描述，就是Thread类，

创建线程的第一种方式：

  步骤：1.定义类继承Thread类

               2.覆写Thread类中的run方法

               3.调用线程的start方法（该方法有俩作用：启动线程，调用run方法）

class Test extends Thread{ Test(String name){super(name);} public void run() {     for(int x=0;x<50;x++) { System.out.println(/*Thread.currentThread()*/this.getName()+"..run..."+x);//获取当前线程对象的名称     } }}public class ThreadDemo1{public static void main(String[] args){Test t1 = new Test("one");//创建一个线程并赋名称Test t2 = new Test("two");t1.start();//有俩作用  启动线程  调用run方法t2.start();for(int x=0;x<50;x++){ System.out.println("hello world");}}}

运行特点：

A.并发性：我们看到的程序（或线程）并发执行，其实是一种假象。有一点需要明确：；在某一时刻，只有一个程序在运行（多核除外），此时cpu是在进行快速的切换，以达到看上去是同时运行的效果。由于切换时间是非常短的，所以我们可以认为是在并发进行。

B.随机性：在运行时，每次的结果不同。由于多个线程都在获取cpu的执行权，cpu执行到哪个线程，哪个线程就会执行。可以将多线程运行的行为形象的称为互相抢夺cpu的执行权。这就是多线程的特点，随机性。执行到哪个程序并不确定。

为什幺覆盖run方法？

Thread类用于描述线程，该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法，也就是说Thraed类中的run方法用于存储线程要运行的代码

/*创建线程的另一只种方法：实现Runnable接口 * 步骤:1.定义类实现Runnable接口 * 2.覆盖Runnable接口中方法 * 3.通过Thread类建立线程对象  有几个线程就建立几个对象 * 4.通过Runnablejie接口的子类对象作为实际参数传递给Thread类的构造函数 * 为什么将Runnablejie接口的子类对象作为实际参数传递给Thread类的构造函数？ * 因为自定义的run方法所属对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法，就必须明确该run方法所属对象 * *//*实现方式与继承方式有何区别：1、实现方式：避免了单继承的局限性。             在定义线程时，建议使用实现方式。2区别：继承Thread：线程代码存放在Thread子类的run方法中。实现Runnable：线程代码存在接口的子类run方法中。需要注意的是：局部变量在每一个线程中都独有一份*/class Ticket implements Runnable{private int tick =100;Object obj = new Object(); public void run(){while(true){synchronized(obj){if(tick >0){try{Thread.sleep(10);}//此处10的单位是毫秒catch(Exception e){}System.out.println(Thread.currentThread().getName()+"..sale.."+tick--);}}}}}public class ThreadDemo2 {public static void main(String[] args){Ticket t = new Ticket();Thread t1 = new Thread(t);Thread t2 = new Thread(t);Thread t3 = new Thread(t);Thread t4 = new Thread(t);t1.start();t2.start();t3.start();t4.start();}}/*同步代码快   synchronized()   {   需要被同步的代码   }      同步的前提   1.必须有两个或两个以上的线程   2.必须是多个线程使用一把锁   3.必须是保证同步中只能有一个线程在运行   好处；解决了多线程的安全问题 弊端;多个线程都需要判断锁，消耗资源   */

线程的运行状态

线程运行状态可用如下图示说明：

需要说明的是：

A.阻塞状态：具备运行资格，但是没有执行权，必须等到cpu的执行权，才转到运行状态，。

B.冻结状态：放弃了cpu的执行资格，cpu不会将执行权分配给这个状态下的线程，必须被唤醒后，此线程要先转换到阻塞状态，等待cpu的执行权后，才有机会被执行到。

二、同步函数中的锁

1.非静态同步函数中的锁

函数续杯对象所调用，那么函数都有一个所属的对象引用，就是this,因此同步函数使用的锁为this。

package ThreadDemo;class Sale implements Runnable  {      private int tick = 100;      boolean flog = true;      public void run()      {          if (flog)          {              //线程一执行               while(true)              {                  //如果对象为obj，则是两个锁，是不安全的；换成this，为一个锁，会安全很多                   synchronized(this)                  {                      if (tick > 0)                    {   try{Thread.sleep(10);}catch(Exception e){}                        System.out.println(Thread.currentThread().getName() + "--code--:" + tick--);                      }                 }                }            }            //线程二执行           else              while(true)                  show();      }      public synchronized void show()      {          if (tick > 0)          {         try{Thread.sleep(10);}catch(Exception e){}            System.out.println(Thread.currentThread().getName() + "----show-----:" + tick--);              }     }  }    class ThreadDemo4  {      public static void main(String[] args)       {          Sale t = new Sale();          Thread t1 = new Thread(t);//创建一个线程           Thread t2 = new Thread(t);//创建一个线程           t1.start();          try{Thread.sleep(10);}catch(Exception e){}//关闭主线程，运行t1        t.flog = false;//开启线程一，即关闭if，让线程二执行else中语句           t2.start();      }}

2.静态同步函数中的锁

如果同步函数被静态修饰后，经验证，使用的锁不是thisl了，因为静态方法中不可定义this,所以，这个锁不再是this了。静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象：类名.class   ;该对象的类型是class

所以静态的同步方法使用的锁是该方法所在的字节码文件对象  ，即类名.class

package ThreadDemo;import java.util.concurrent.locks.*;  //线程间通信  唤醒机制  生产者消费者  3个public class ThreadDemo6 {public static void main(String[] args){          Resouse r = new Resouse();          Producer p = new Producer(r);          Consumer c = new Consumer(r);          Thread t1 = new Thread(p);          Thread t2 = new Thread(c);          Thread t3 = new Thread(p);          Thread t4 = new Thread(c);          t1.start();          t2.start();          t3.start();          t4.start();      }  }    class Resouse{      private String name;      private int count = 1;      private boolean flag =  false;       private Lock lock = new ReentrantLock();      private Condition condition_P = lock.newCondition();      private Condition condition_C = lock.newCondition();  //要唤醒全部，否则都可能处于冻结状态，那么程序就会停止。这和死锁有区别的。       public void set(String name)throws InterruptedException{          lock.lock();          try{              while(flag)//循环判断，防止都冻结状态                   condition_P.await();              this.name = name + "--" + count++;              System.out.println(Thread.currentThread().getName() + "..生成者--" + this.name);              flag = true;              condition_C.signal();          }finally{              lock.unlock();//释放锁的机制一定要执行           }             }      public void out()throws InterruptedException{          lock.lock();          try{              while(!flag)//循环判断，防止都冻结状态                   condition_C.await();              System.out.println(Thread.currentThread().getName() + "..消费者." + this.name);              flag = false;              condition_P.signal();//唤醒全部           }finally{              lock.unlock();          }      }  }    class Producer implements Runnable{      private Resouse r;      Producer(Resouse r){          this.r = r;      }      public void run(){          while(true){              try{                  r.set("--商品--");              }catch (InterruptedException e){}          }      }  }    class Consumer implements Runnable{      private Resouse r;      Consumer(Resouse r){          this.r = r;      }      public void run(){          while(true){              try{                  r.out();              }catch (InterruptedException e){}          }      }  }  /*等待唤醒机制：1、显式锁机制和等待唤醒机制：在JDK 1.5中，提供了改进synchronized的升级解决方案。将同步synchronized替换为显式的Lock操作，将Object中的wait，notify，notifyAll替换成Condition对象，该对象可对Lock锁进行获取。这就实现了本方唤醒对方的操作。在这里说明几点：1）、对于wait，notify和notifyAll这些方法都是用在同步中，也就是等待唤醒机制，这是因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。2）、而这些方法都定义在Object中，是因为这些方法操作同步中的线程时，都必须表示自己所操作的线程的锁，就是说，等待和唤醒的必须是同一把锁。不可对不同锁中的线程进行唤醒。所以这就使得程序是不良的，因此，通过对锁机制的改良，使得程序得到优化。3）、等待唤醒机制中，等待的线程处于冻结状态，是被放在线程池中，线程池中的线程已经放弃了执行资格，需要被唤醒后，才有被执行的资格。2、对于上面的程序，有两点要说明：1）、为何定义while判断标记：原因是让被唤醒的线程再判断一次。避免未经判断，线程不知是否应该执行，就执行本方的上一个已经执行的语句。如果用if，消费者在等着，两个生成着一起判断完flag后，cpu切换到其中一个如t1，另一个t3在wait，当t1唤醒冻结中的一个，是t3（因为它先被冻结的，就会先被唤醒），所以t3未经判断，又生产了一个。而没消费。2）这里使用的是signal方法，而不是signalAll方法。是因为通过Condition的两个对象，分别唤醒对方，这就体现了Lock锁机制的灵活性。可以通过Contidition对象调用Lock接口中的方法，就可以保证多线程间通信的流畅性了。 * */

 

这简单介绍几个Thread中的方法：

1、停止线程：

在java 1.5之后，就不再使用stop方法停止线程了。那么该如何停止线程呢？只有一种方法，就是让run方法结束。

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

注：

特殊情况：当线程处于冻结状态，就不会读取标记，那么线程就不会结束。

   interrupt()。

此方法是为了让线程中断，但是并没有结束运行，让线程恢复到运行状态，再判断标记从而停止循环，run方法结束，线程结束。

 2、守护线程：---setDaemon()

可将一个线程标记为守护线程，直接调用这个方法。此方法需要在启动前调用守护线程在这个线程结束后，会自动结束，则Jvm虚拟机也结束运行。

 3、临时加入线程：--join()

特点：当A线程执行到B线程方法时，A线程就会等待，B线程都执行完，A才会执行。join可用来临时加入线程执行。

4、优先级：

setPriority()：

在Thread中，存在着1~10这十个执行级别，最高的是 MAX_PRIORITY 为10，最低是 MIN_PRIORITY 为1，默认优先级是 NORM_PRIORITY 为5；但是并不是优先级越高，就会一直执行这个线程，只是说会优先执行到这个线程，此后还是有其他线程会和此线程抢夺cpu执行权的。

优先级是可以设定的，可通过setPriority()设定，如：setPriority(Thread.MAX_PRIORITY)设优先级为最大。

yield()：

此方法可暂停当前线程，而执行其他线程。通过这个方法，可稍微减少线程执行频率，达到线程都有机会平均被执行的效果

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