黑马程序员----java基础--多线程

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、进程、线程、多进程的概念

1、进程和线程

进程：正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。

线程：其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。

一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序，每个线程在栈区中都有自己的执行空间，自己的方法区、自己的变量。

2、java虚拟机就是多线程程序

jvm在启动的时，首先有一个主线程，负责程序的执行，调用的是main函数。主线程执行的代码都在main方法中。

当产生垃圾时，收垃圾的动作，是不需要主线程来完成，因为这样，会出现主线程中的代码执行会停止，会去运行垃圾回收器代码，效率较低，所以由单独一个线程来负责垃圾回收。

3、多线程的好坏之处

多线程的好处：解决了多部分代码同时运行的问题。 多线程的弊端：线程太多，会导致效率的降低。 其实，多个应用程序同时执行都是CPU在做着快速的切换完成的。这个切换是随机的。哪个线程抢到了cpu的执行权，哪个线程就执行。CPU的切换是需要花费时间的，从而导致了效率的降低。

创建线程的目的就是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

二、创建线程的方式

1、获取当前线程名称

Thread.currentThread().getName();

线程的名称是由：Thread-编号定义的。编号从0开始。

线程要运行的代码都统一存放在了run方法中。

2、创建线程的方式

(1)、第一种方式：继承Thread类，由子类复写run方法。

1. 定义一个类继承Thread类。2. 覆盖Thread类中的run方法。3. 直接创建Thread的子类对象创建线程。4. 调用start方法开启线程并调用线程的任务run方法执行。

run方法就是封装自定义线程运行任务的函数，run方法中定义的就是线程要运行的任务代码。记住：把需要开启多线程的运行代码都写到run方法中。

代码演示：

 1 //继承Thread类，复写run方法 2 class Demo extends Thread 3 { 4     public void run(){//run方法内不能抛异常，只能try catch。因为该方法是复写Thread类中的run方法。Thread类中的run方法没有抛异常 5         for (int x=0;x<70 ;x++ ) 6         { 7             System.out.PRintln(Thread.currentThread().getName()+"....."+x); 8         } 9     }10 }11 class ThreadDemo 12 {13     public static void main(String[] args) //开启了两个线程：Demo和main。两个线程交替运行14     {15         new Demo().start();//创建子类对象，并开启线程，调用run方法16         for (int x=0;x<70 ;x++ )17         {18             System.out.println(Thread.currentThread().getName()+":::"+x);//mian函数的线程名称就是：main19         }20     }21 }

自定义线程名称的方法

 1 class Demo extends Thread 2 { 3     private String name; 4     Demo(String name){ 5         super(name); 6     } 7     public void run(){ 8         System.out.println(Thread.currentThread().getName()); 9     }10 }11 class ThreadDemo12 {13     publici static void main(Stirng[] args){14         new Demo("线程一").start();15         new Demo("线程二").start();16     }17 }                   

(2)、创建线程的第二种方式：实现Runnable接口,复写run方法。

1.定义类实现Runnable接口

2.覆盖接口中的run方法（用于封装线程要运行的代码）

3.通过Thread类创建线程对象

4.将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。

为什么要传递呢？线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务。

5.调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。

为什么要有Runnable接口的出现？

1.通过继承Thread类的方式，可以完成多线程的建立。但是这种方式有一个局限性，如果一个类已经有了自己的父类，就不可以继承Thread类，因为java单继承的局限性。

可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢？

只有对该类进行额外的功能扩展，java就提供了一个接口Runnable。这个接口中定义了run方法，其实run方法的定义就是为了存储多线程要运行的代码。

所以，通常创建线程都用第二种方式。因为实现Runnable接口可以避免单继承的局限性。

2.其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。所以Thread类在描述线程时，内部定义的run方法，也来自于Runnable接口。

实现Runnable接口可以避免单继承的局限性。而且，继承Thread，是可以对Thread类中的方法，进行子类复写的。但是不需要做这个复写动作的话，只为定义线程代码存放位置，实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。

代码演示：

 1 //实现Runnable，复写run方法 2 class Demo implements Runnable 3 { 4     public void run(){ 5         for (int x=0;x<60 ;x++ ) 6         {             7             System.out.println(Thread.currentThread().getName()+".."+x); 8         } 9     }10 }11 class ThreadDemo12 {13     public static void main(String[] args) 14     {15         new Thread(new Demo()).start();16         for (int x=0;x<60 ; x++)17         {18             System.out.println(Thread.currentThread().getName()+":::::"+x);19         }20     }21 }

(3)、线程状态

被创建：start()

运行：具备了执行资格，同时也具备执行权

临时阻塞状态：线程具备cpu的执行资格，但是没有cpu的执行权

冻结：sleep(time)，wait()--notify()，失去执行资格和执行权。sleep方法时间到或者调用notify()方法时，获得执行资格，变为临时状态

消亡：stop()方法，或者run()方法结束

三、线程安全问题

1、多线程安全问题的原因

通过图解：发现一个线程在执行多条语句时，并运算同一个数据时，在执行过程中，其他线程参与进来，并操作了这个数据。导致到了错误数据的产生。

涉及到两个因素：

1.多个线程在操作共享数据。

2.有多条语句对共享数据进行运算。

原因：这多条语句，在某一个时刻被一个线程执行时，还没有执行完，就被其他线程执行了。

2、线程安全问题的解决方案

解决安全问题的原理：

只要将操作共享数据的语句在某一时段让一个线程执行完，在执行过程中，其他线程不能进来执行就可以解决这个问题。必须要当前线程把这些代码都执行完毕后，其他线程才可以参与运算。

解决同步的方式：(1)、同步代码块的格式： synchronized(对象){// 任意对象都可以。这个对象就是锁。 需要被同步的代码; }同步的好处：解决了线程的安全问题。同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。同步的前提：必须有多个线程并使用同一个锁。

需求：模拟4个线程同时卖100张票。

 1 //加上同步代码块后 2 class Ticket implements Runnable 3 { 4     private int ticket=100; 5     private Object obj=new Object(); 6     public void run(){ 7         while (true) 8         { 9             synchronized(obj){//加上同步代码块后，obj对象相当于一把锁，一个线程进去后,其他线程无法进去，只有当这个线程执行完，跳出同步后，另一个才能进去10                 if (ticket>0)//一个线程进同步有两个隐式操作，刚进同步后：上锁，跳出同步后：释放锁11                 {12                     try{Thread.sleep(20);}catch(Exception e){}//让线程停止20毫秒，这时候出现了线程等于0、-1、-2的情况13                     System.out.println(Thread.currentThread().getName()+"..."+ticket--);//出现问题的原因是：线程停止了20毫秒后，继续运行的时候没有判断if的条件。14                 }15             }16         }17         18     }    19 }20 class TicketDemo 21 {22     public static void main(String[] args) 23     {24         Ticket t=new Ticket();25         new Thread(t).start();26         new Thread(t).start();27         new Thread(t).start();28         new Thread(t).start();29     }30 }

需求：储户，两个，每个都到银行存钱，每次存100，共存三次。

 1 class Bank 2 { 3     private Object obj=new Object(); 4     private int sum; 5     public void add(int num){ 6         synchronized(obj){ 7             sum=sum+num; 8             try{Thread.sleep(10);}catch(Exception e){} 9             System.out.println("sum="+sum);10         }11     }12 }13 class Person implements Runnable14 {15     private Bank b=new Bank();16     public void run(){17         for(int x=0;x<3;x++){18             b.add(100);19         }20     }21 }22 class BankDemo 23 {24     public static void main(String[] args) 25     {26         Person p=new Person();27         new Thread(p).start();28         new Thread(p).start();29     }30 }

(2)、同步函数

同步函数：其实就是将同步关键字定义在函数上，让函数具备了同步性。

上面的代码可以用同步函数代替同步代码块。

1 class Bank2 {3     private int sum;4     public synchronized void add(int num){        5         sum=sum+num;6         try{Thread.sleep(10);}catch(Exception e){}7         System.out.println("sum="+sum);        8     }9 }

同步函数用的是哪一个锁呢？函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。

同步函数和同步代码块的区别：1. 同步函数的锁是固定的this。2. 同步代码块的锁是任意的对象。建议使用同步代码块。

关于同步函数用的是this锁，可以通过该程序进行验证。使用两个线程来买票。一个线程在同步代码块中。一个线程在同步函数中。都在执行卖票动作。

 1 class Ticket implements Runnable 2 { 3     private int ticket=100; 4      boolean flag; 5     public void run(){ 6         if(flag){ 7             while (true) 8             { 9                 synchronized(this){10                     if(ticket>0){11                         try{Thread.sleep(10);}catch(Exception e){}12                         System.out.println(Thread.currentThread().getName()+"..obj."+ticket--);13                     }14                 }                15             }            16         }17         else18             while(true)19                 show();20     }21     public synchronized void show(){        22         if(ticket>0){23             try{Thread.sleep(10);}catch(Exception e){}24             System.out.println(Thread.currentThread().getName()+"::this::"+ticket--);25         }26         27     }28 }29 class ThisLockDemo 30 {31     public static void main(String[] args) 32     {33         Ticket t=new Ticket();34         new Thread(t).start();35         try{Thread.sleep(10);}catch(Exception e){}//让线程一先sleep一会，这时候主线程还获取执行权，继续向下执行36         t.flag=true;//标记为true，这时候会运行show方法中的代码37         new Thread(t).start();38     }39 }

上面的代码显示两个线程交替执行而且把100张票卖完了，而且没有出现0号和负数的票，说明两个线程是安全的，同时也说明了同步函数用的锁是this。

(3)、静态同步函数

当同步函数被static修饰时，这时的同步用的是哪个锁呢？

静态函数在加载时所属于类，这时有可能还没有该类产生的对象，但是该类的字节码文件加载进内存就已经被封装成了对象，这个对象就是该类的字节码文件对象。

所以静态加载时，只有一个对象存在，那么静态同步函数就使用的这个对象。

这个对象就是 类名.class。

还是用卖票的程序可以验证静态同步函数的锁是.class。

 1 class Ticket implements Runnable 2 { 3     private static int ticket=100; 4     boolean flag; 5     public void run(){ 6         if(flag){ 7             while (true) 8             { 9                 synchronized(Ticket.class){10                     if(ticket>0){11                         try{Thread.sleep(10);}catch(Exception e){}12                         System.out.println(Thread.currentThread().getName()+"..obj."+ticket--);13                     }14                 }                15             }            16         }17         else18             while(true)19                 show();20     }21     public static synchronized void show(){        22         if(ticket>0){23             try{Thread.sleep(10);}catch(Exception e){}24             System.out.println(Thread.currentThread().getName()+"::this::"+ticket--);25         }26         27     }28 }29 class ThisLockDemo 30 {31     public static void main(String[] args) 32     {33         Ticket t=new Ticket();34         new Thread(t).start();35         try{Thread.sleep(10);}catch(Exception e){}//让线程一先sleep一会，这时候主线程还获取执行权，继续向下执行36         t.flag=true;//标记为true，这时候会运行show方法中的代码37         new Thread(t).start();38     }39 }

在一个类中只有一个同步，可以使用同步函数。如果有多同步，必须使用同步代码块，来确定不同的锁。所以同步代码块相对灵活一些。

四、多线程下的单例设计模式

饿汉式不存在线程安全问题，因为操作的代码只有一句。

1 class Single 2 {3     private Single(){}4     private static final Single s=new Single();5     public static Single getInstance(){6         return s;7     }8 }

 1 class Single 2 { 3     private Single(){} 4     private static Single s=null; 5     public static Single getInstance(){//如果在函数上加上synchronized就出现了每次都判断锁 6         if(s==null){//双重判断是否为空可以解决低效问题。 7             synchronized(Single.class){ 8                 if(s==null){ 9                     s=new Single();            10                 }11             }            12         }        13         return s;14     }15 }

五、死锁

 1 class DeadLock implements Runnable 2 { 3     private boolean flag; 4     DeadLock(boolean flag){ 5         this.flag=flag; 6     } 7     public void run(){     8         if(flag){ 9             while (true)10             {11                 synchronized(MyLock.locka){//同步代码块中嵌套同步代码块12                     System.out.println("if....locka...");13                     synchronized(MyLock.lockb){14                         System.out.println("if....lockb...");15                     }16                 }17             }                18         }19         else{20             while (true)21             {22                 synchronized(MyLock.lockb){23                     System.out.println("else-----lockb--");24                     synchronized(MyLock.locka){25                         System.out.println("else-----locka---");26                     }27                 }28             }                29         }30     }    31 }32 class MyLock33 {34     public static MyLock locka=new MyLock();35     public static MyLocks lockb=new MyLock();36 }37 class DeadLockDemo 38 {39     public static void main(String[] args) 40     {41         new Thread(new DeadLock(true)).start();42         new Thread(new DeadLock(false)).start();43 44     }45 }

六、线程间通信问题

线程间通信：思路：多个线程在操作同一个资源，但是操作的动作却不一样。

1.将资源封装成对象。

2.将线程执行的任务(任务其实就是run方法。)也封装成对象。

等待/唤醒机制涉及的方法：1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。3. notifyAll()：唤醒线程池中的所有线程。

这些方法都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？　　因为这些方法在操作同步中线程时，都必须要标识它们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

wait和sleep区别？1.wait可以指定时间也可以不指定。sleep必须指定时间。2.在同步中时，对CPU的执行权和锁的处理不同。wait：释放执行权，释放锁。sleep：释放执行权，不释放锁。

(1)、一个生产者，一个消费者。即： 一个线程负责生产，一个线程负责消费

代码演示：

 1 class Resource 2 { 3     private String name; 4     private String sex; 5     private boolean flag; 6     public synchronized void set(String name,String sex){ 7         if(flag)//如果为真，执行下面wait方法，线程处于等待状态，释放了执行权并且放弃了锁。 8             try{this.wait();}catch(Exception e){} 9         //如果标记不为true，那么往里面存数据。10         this.name=name;11         this.sex=sex;12         flag=true;13         this.notify();//唤醒线程池中第一个等待的线程14     }15     public synchronized void out(){16         if(!flag)17             try{this.wait();}catch(Exception e){}18         System.out.println(name+"...."+sex);19         flag=false;20         this.notify();21     }22 }23 class Input implements Runnable24 {25     private Resource r;//为了保证操作的是同一资源，所以把资源对象传参进去26     Input(Resource r){27         this.r=r;28     }29     public void run(){30         int x=0;31         while (true)32         {33             if(x==0)34                 r.set("mike","man");            35             else36                 r.set("丽丽","女女女女女女");37             x=(x+1)%2;//切换输入内容38         }39     }40 }41 class Output implements Runnable42 {43     private Resource r;44     Output(Resource r){45         this.r=r;46     }47     public void run(){48         while (true)49         {50             r.out();51         }52     }    53 }54 class ResourceDemo55 {56     public static void main(String[] args) 57     {58         Resource r=new Resource();//创建资源对象59         new Thread(new Input(r)).start();//开启两个线程60         new Thread(new Output(r)).start();61     }62 }

(2)、多生产--多消费问题

上面的例子是一个输入一个输出，现在是多个线程执行输入同时多条线程执行输出。即：多个线程操作生产，多个线程操作消费。这是开发中最常见的，希望能够掌握。

 1 class Resource 2 { 3     private String name; 4     private int count=1; 5     private boolean flag=false; 6     public synchronized void set(String name){ 7         while(flag)//循环判断标记来防止线程等待被唤醒后往下执行，直接生产覆盖上一个数据。 8             try{this.wait();}catch(Exception e){} 9         this.name=name+"....."+count++;10         System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);11         flag=true;12         this.notifyAll();//唤醒线程池中的全部线程13     }14     public synchronized void out(){15         while(!flag)16             try{this.wait();}catch(Exception e){}17         System.out.println(Thread.currentThread().getName()+"----消费者-------"+this.name);18         flag=false;19         this.notifyAll();//唤醒线程池中的全部线程20     }21 }22 class Producer implements Runnable23 {24     private Resource r;25     Producer(Resource r){26         this.r=r;27     }28     public void run(){29         while (true)30         {31             r.set("商品");32         }33     }34 }35 class Consumer implements Runnable36 {37     private Resource r;38     Consumer(Resource r){39         this.r=r;40     }41     public void run(){42         while (true)43         {44             r.out();45         }46     }47 }48 class  ProducerConsumerDemo49 {50     public static void main(String[] args) 51     {52         Resource r=new Resource();53         new Thread(new Producer(r)).start();54         new Thread(new Producer(r)).start();55         new Thread(new Consumer(r)).start();56         new Thread(new Consumer(r)).start();57 58     }59 }

七、线程间通信-生产者消费者JDK1.5升级版

　　上面的程序虽然能够解决问题，但是发现每次都唤醒全部线程，这样会导致线程都去抢夺cpu执行权，效率有点低，所以JDK在升级1.5的时候推出了一个接口Lock接口。它的出现就替代了同步代码块或者同步函数，将同步的隐式操作变成显示锁操作。同时更为灵活，可以一个锁上加上多组监视器。。

　　在之前的版本中使用Object类中wait、notify、notifyAll的方法来完成的，那是因为同步中的锁是任意对象，所以操作时的等待唤醒的方法是都是定义在Object类中。而现在锁是指定对象Lock，所以查找等待唤醒机制方式需要通过Lock接口来完成.而Lock接口中并没有直接操作等待唤醒的方法，而是将这些方法又单独的封装了一个对象中，这个对象就是Condition，将Object中的三个方法进行了单独的封装，并提供了功能一致的方法await()、signal()、signalAll()。所以Condition接口出现替代了Object中的wait、notify、notifyAll方法。将这些监视器方法单独进行了封装，变成Condition监视器对象，可以任意锁进行组合。

Lock接口

1 Lock lock=new ReentrantLock();//创建Lock对象2 void    lock();//获取锁。3 void    unlock();//释放锁，为了防止异常出现，导致锁无法被关闭，所以锁的关闭动作要放在finally中。4 Condition　　newCondition();//获取Condition对象

Condition接口

1 void    await();//对应于Object中的wait方法2 void    signal();//对应于Object中的notify方法3 void    signalAll();//对应于Object中的notifyAll方法

JDK1.5多生产--多消费问题代码

 1 import java.util.concurrent.locks .*; 2 class Resource 3 { 4     private boolean flag; 5     private Lock lock=new ReentrantLock();//创建Lock对象 6     private Condition procondition=lock.newCondition();//创建Condition对象 7     private Condition concondition=lock.newCondition(); 8     private int count=1; 9     private String name;10     public void set(String name){11         lock.lock();//显示的加锁12         try13         {14             while(flag)15                 procondition.await();//await替换了wait；16             this.name=name+"..."+count++;17             System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);18             flag=true;19             concondition.signal();//signal替换了notify20         }21         catch (Exception e)22         {23             System.out.println(e);24         }25         finally{26             lock.unlock();//释放锁，释放资源的动作一定要放在finally块中27         }28         29     }30     public void out(){31         lock.lock();32         try33         {34             while(!flag)35                 concondition.await();36             System.out.println(Thread.currentThread().getName()+"------消费者-----"+this.name);37             flag=false;38             procondition.signal();39         }40         catch (Exception e)41         {42             System.out.println(e);43         }44         finally{45             lock.unlock();46         }47     }48 }49 class Producer implements Runnable50 {51     private Resource r;52     Producer(Resource r){53         this.r=r;54     }55     public void run(){        56         while (true)57         {            58             r.set("商品");59         }60     }61 }62 class Consumer implements Runnable63 {64     private Resource r;65     Consumer(Resource r){66         this.r=r;67     }68     public void run(){69         while (true)70         {71             r.out();72         }73     }74 }75 class ProducerConsumerDemo2 76 {77     public static void main(String[] args) 78     {79         Resource r=new Resource();80         new Thread(new Producer(r)).start();81         new Thread(new Producer(r)).start();82         new Thread(new Consumer(r)).start();83         new Thread(new Consumer(r)).start();84     }85 }

八、Thread类中其他方法

1、停止线程

查看API发现线程停止方法stop方法已经过时了，所以我们无法在使用。其实让线程停止的原理就是：run方法结束。

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

所以run方法中通常定义循环，指定控制住循环线程即可结束。

特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。Thread类提供该方法 interrupt()，interrupt()方法将线程从冻结状态强制恢复到运行状态中来，让线程具备CPU的执行资格。强制动作会发生InterruptedException，一定要记得处理。

 1 class StopThread implements Runnable{ 2        private boolean flag = true; 3        public void run(){ 4              while(flag ){ 5                   System. out.println(Thread.currentThread().getName() + "..."); 6             } 7        } 8        public void setFlag(){ 9              flag = false ;10        }11 }12  13 class StopThreadDemo{14        public static void main(String[] args){15             StopThread st = new StopThread();16             new Thread(st).start();17             new Thread(st).start();        18 19              int num = 0;20             while(true){21                    if(num++ == 50){22                         st.setFlag();23                          break;24                   }25                   System. out.println(Thread.currentThread().getName()+"..."+ num);26              }27              System. out.println("over" );28       }29 }

 1 class StopThread implements Runnable{ 2        private boolean flag = true; 3        public synchronized void run(){ 4              while(flag){ 5                    try{ 6                         wait(); 7                   } catch(Exception e){ 8                         System.out.println(e); 9                         flag = false;10                   }11                   System.out.println(Thread.currentThread().getName() );12             }13       }14        public void setFlag(){15             flag = false;16       }17 }18 19 class StopThreadDemo{20        public static void main(String[] args){21             StopThread st = new StopThread();22             Thread t1 = new Thread(st).start();23             Thread t2 = new Thread(st).start();    24              int num = 0;25              while(true){26                    if(num++ == 50){27                         t1.interrupt();28                         t2.interrupt();29                          break;30                   }31                   System.out.println( Thread.currentThread().getName()+"..." + num);32             }33             System.out.println( "over");34       }35 }

2、守护线程

setDaemon，将该线程标记为守护线程或用户线程。正在运行的线程都是守护线程时，Java 虚拟机退出。该方法必须在启动线程前调用。setDaemon(boolean):将线程标记为后台线程，后台线程和前台线程一样，开启，一样抢执行权运行，只有在结束时，有区别，当前台线程都运行结束后，后台线程会自动结束。

3、join方法

当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。join可以用来临时加入线程执行。

4、setPriority方法

用来设置优先级

MAX_PRIORITY最高优先级10

MIN_PRIORITY 最低优先级1

NORM_PRIORITY分配给线程的默认优先级

5、yield方法

暂停当前线程，让其他线程执行，可以让线程释放执行权

6、toString方法

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