一、线程之间的通信

1.1、线程之间的通信方法

多个线程在处理统一资源，但是任务却不同，这时候就需要线程间通信。
    等待/唤醒机制涉及的方法：
    1. wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。
    2. notify()：唤醒线程池中的一个线程（任何一个都有可能）。
    3. notifyAll()：唤醒线程池中的所有线程。
  备注
    1、这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法。
    2、必须要明确到底操作的是哪个锁上的线程！
    3、wait和sleep区别？
         1）wait可以指定时间也可以不指定。sleep必须指定时间。
         2）在同步中时，对CPU的执行权和锁的处理不同。
         wait：释放执行权，释放锁。
         sleep：释放执行权，不释放锁。
    为什么操作线程的方法wait、notify、notifyAll定义在了object类中，因为这些方法是监视器的方法，监视器其实就是锁。
锁可以是任意的对象，任意的对象调用的方式一定在object类中。

1.2、两个线程交替打印1-100

package com.pb.thread.demo1;public class Demo {  private int num=1;    /*   * 打印偶数   */  public synchronized void put(){          if(num%2==0){        try {          wait();        } catch (InterruptedException e) {          e.printStackTrace();        }      }            notify();      System.out.println(Thread.currentThread().getName()+","+num);      num++;  }  /*   * 打印奇数   */  public synchronized void get(){      if(num%2!=0){        try {          //当前线程等待          wait();        } catch (InterruptedException e) {          e.printStackTrace();        }      }      //唤醒另一等待中的线程      notify();      System.out.println(Thread.currentThread().getName()+","+num);      num++;  }  public int getNum() {    return num;  }  public void setNum(int num) {    this.num = num;  }    }

package com.pb.thread.demo1;/** * 打印偶数 * @author denny * */public class A implements Runnable {    Demo demo;  public A(Demo demo){    this.demo=demo;  }  @Override  public void run() {    while(demo.getNum()<100){      demo.put();          }  }}package com.pb.thread.demo1;/** * 打印奇数 * @author denny * */public class B implements Runnable {  Demo demo;  public B(Demo demo) {    this.demo = demo;  }  @Override  public void run() {    while(demo.getNum()<100){      demo.get();          }  }}

测试类

package com.pb.thread.demo1;/** * 2个线程交替打印1-100 * @author denny * */public class Test {  public static void main(String[] args) {    Demo demo=new Demo();    A a=new A(demo);    B b=new B(demo);    Thread t1=new Thread(a);    Thread t2=new Thread(b);    t1.start();    t2.start();  }}

结果：

Picked up JAVA_TOOL_OPTIONS: -javaagent:/usr/share/java/jayatanaag.jar Thread-0,1Thread-1,2Thread-0,3Thread-1,4Thread-0,5Thread-1,6Thread-0,7Thread-1,8Thread-0,9Thread-1,10Thread-0,11Thread-1,12Thread-0,13Thread-1,14Thread-0,15Thread-1,16Thread-0,17Thread-1,18Thread-0,19Thread-1,20Thread-0,21Thread-1,22Thread-0,23Thread-1,24Thread-0,25Thread-1,26Thread-0,27Thread-1,28Thread-0,29Thread-1,30Thread-0,31Thread-1,32Thread-0,33Thread-1,34Thread-0,35Thread-1,36Thread-0,37Thread-1,38Thread-0,39Thread-1,40Thread-0,41Thread-1,42Thread-0,43Thread-1,44Thread-0,45Thread-1,46Thread-0,47Thread-1,48Thread-0,49Thread-1,50Thread-0,51Thread-1,52Thread-0,53Thread-1,54Thread-0,55Thread-1,56Thread-0,57Thread-1,58Thread-0,59Thread-1,60Thread-0,61Thread-1,62Thread-0,63Thread-1,64Thread-0,65Thread-1,66Thread-0,67Thread-1,68Thread-0,69Thread-1,70Thread-0,71Thread-1,72Thread-0,73Thread-1,74Thread-0,75Thread-1,76Thread-0,77Thread-1,78Thread-0,79Thread-1,80Thread-0,81Thread-1,82Thread-0,83Thread-1,84Thread-0,85Thread-1,86Thread-0,87Thread-1,88Thread-0,89Thread-1,90Thread-0,91Thread-1,92Thread-0,93Thread-1,94Thread-0,95Thread-1,96Thread-0,97Thread-1,98Thread-0,99Thread-1,100

 交替打印

一个输入，一个输出

package com.pb.thread.demo3;/** * * @author Denny * 线程间通讯： * 其它就是多个线程在操作同一个资源 * 只是操作的动作不同 * */public class Person {    private String name;  private int age;  private String gender;  private boolean flag=false;  public String getName() {    return name;  }  public void setName(String name) {    this.name = name;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  public String getGender() {    return gender;  }  public void setGender(String gender) {    this.gender = gender;  }  public boolean getFlag() {    return flag;  }  public void setFlag(boolean flag) {    this.flag = flag;  }      }//======================package com.pb.thread.demo3;public class Input implements Runnable {  private Person person;  public Input(Person person) {    this.person = person;  }  @Override  public void run() {    int x = 0;    while (true) {      synchronized (person) {        if (person.getFlag()) {          try {            person.wait();          } catch (InterruptedException e) {            e.printStackTrace();          }        }        if (x == 0) {          person.setName("jony");          person.setAge(33);          person.setGender("man");        } else {          person.setName("李丽");          person.setAge(23);          person.setGender("女");        }        x = (x + 1) % 2;        person.setFlag(true);        person.notify();      }    }  }  public Person getPerson() {    return person;  }  public void setPerson(Person person) {    this.person = person;  }}//=======================package com.pb.thread.demo3;public class Output implements Runnable {  private Person person;  public Output(Person person) {    this.person = person;  }  @Override  public void run() {    while (true) {      synchronized (person) {        if (!(person.getFlag())) {          try {            person.wait();          } catch (InterruptedException e) {            e.printStackTrace();          }        }        System.out.println("姓名：" + person.getName() + "年龄:" + person.getAge() + ",性别：" + person.getGender());        person.setFlag(false);        person.notify();      }    }  }  public Person getPerson() {    return person;  }  public void setPerson(Person person) {    this.person = person;  }}//====================package com.pb.thread.demo3;/** * * @author Denny *wait(),notify(),notifyAll() *都使用在同步中，因为要对持胡监视器（锁）的线程操作 *因为只有同步才有锁 *为什么这些操作线程的方法要定义在Object类中呢？ *国为这些方法在操作线程时，都必须要标识它们所操作作线程只有的锁 *只有同一个锁上的被等待，可以被同一个锁上的notify()唤醒 *不可以对不同锁中的线程唤醒 *等待和唤醒必须是同一个锁。 *锁可以是任意对象，可以被任意对象调用的方法在Object中. */public class Test {  public static void main(String[] args) {    Person person=new Person();    Input input=new Input(person);    Output output = new Output(person);    Thread t1=new Thread(input);    Thread t2=new Thread(output);    t1.start();    t2.start();  }}

优化以上代码

package com.pb.thread.demo3;/** * * @author Denny * 线程间通讯： * 其它就是多个线程在操作同一个资源 * 只是操作的动作不同 * */public class Person {    private String name;  private int age;  private String gender;  private boolean flag;      public synchronized void setThis(String name,int age,String gender){        if(flag){      try {        wait();      } catch (InterruptedException e) {        e.printStackTrace();      }    }    this.name=name;    this.age=age;    this.gender=gender;    this.flag=true;    notify();      }  public synchronized void getThis(){    if(!flag){      try {        wait();      } catch (InterruptedException e) {        e.printStackTrace();      }    }    System.out.println("姓名：" + this.name + "年龄:" + this.age + ",性别：" + this.gender);    this.flag=false;    notify();  }  public String getName() {    return name;  }  public void setName(String name) {    this.name = name;  }  public int getAge() {    return age;  }  public void setAge(int age) {    this.age = age;  }  public String getGender() {    return gender;  }  public void setGender(String gender) {    this.gender = gender;  }  public boolean getFlag() {    return flag;  }  public void setFlag(boolean flag) {    this.flag = flag;  }      }//====================package com.pb.thread.demo3;public class Input implements Runnable {  private Person person;  public Input(Person person) {    this.person = person;  }  @Override  public void run() {    int x = 0;    while (true) {              if (x == 0) {              person.setThis("jony", 33,"man");        } else {              person.setThis("李丽", 23,"女");        }        x = (x + 1) % 2;      }        }  public Person getPerson() {    return person;  }  public void setPerson(Person person) {    this.person = person;  }}//========================package com.pb.thread.demo3;public class Output implements Runnable {  private Person person;  public Output(Person person) {    this.person = person;  }  @Override  public void run() {    while (true) {            person.getThis();          }  }  public Person getPerson() {    return person;  }  public void setPerson(Person person) {    this.person = person;  }}//=================package com.pb.thread.demo3;/** * * @author Denny *wait(),notify(),notifyAll() *都使用在同步中，因为要对持胡监视器（锁）的线程操作 *因为只有同步才有锁 *为什么这些操作线程的方法要定义在Object类中呢？ *国为这些方法在操作线程时，都必须要标识它们所操作作线程只有的锁 *只有同一个锁上的被等待，可以被同一个锁上的notify()唤醒 *不可以对不同锁中的线程唤醒 *等待和唤醒必须是同一个锁。 *锁可以是任意对象，可以被任意对象调用的方法在Object中. */public class Test {  public static void main(String[] args) {    Person person=new Person();    new Thread(new Input(person)).start();    new Thread(new Output(person)).start();      /*  Input input=new Input(person);    Output output = new Output(person);    Thread t1=new Thread(input);    Thread t2=new Thread(output);    t1.start();    t2.start();*/  }}

姓名：李丽年龄:23,性别：女姓名：jony年龄:33,性别：man姓名：李丽年龄:23,性别：女姓名：jony年龄:33,性别：man姓名：李丽年龄:23,性别：女姓名：jony年龄:33,性别：man

二、生产者与消费者

2.1、单个生产者和单个消费者

package com.pb.thread.demo4;public class Product {  private String name;    private int count;    private boolean flag;      //生产  public synchronized void set(String name){    if(flag){      try {        wait();      } catch (InterruptedException e) {        e.printStackTrace();      }    }    this.name=name+"..."+count++;    System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);    this.flag=true;    notify();  }  public synchronized void get(){    if(!flag){      try {        wait();      } catch (InterruptedException e) {        e.printStackTrace();      }    }    System.out.println(Thread.currentThread().getName()+"--------消费者------------"+name);    this.flag=false;    notify();  }}//======================package com.pb.thread.demo4;public class Producter implements Runnable {    private Product product;  public Producter(Product product){    this.product=product;  }  @Override  public void run() {    while(true){      product.set("产品");    }  }}//================package com.pb.thread.demo4;public class Consumer implements Runnable {  private Product product;  public Consumer(Product product){    this.product=product;  }  @Override  public void run() {    while(true){      product.get();    }  }}//================package com.pb.thread.demo4;public class Test {  public static void main(String[] args) {    Product p=new Product();    Producter producter=new Producter(p);    Consumer consumer=new Consumer(p);    Thread t1=new Thread(producter);    Thread t2=new Thread(consumer);    t1.start();    t2.start();  }}

结果：

Thread-0---生产者---产品...20901Thread-1--------消费者------------产品...20901Thread-0---生产者---产品...20902Thread-1--------消费者------------产品...20902Thread-0---生产者---产品...20903Thread-1--------消费者------------产品...20903Thread-0---生产者---产品...20904Thread-1--------消费者------------产品...20904Thread-0---生产者---产品...20905Thread-1--------消费者------------产品...20905Thread-0---生产者---产品...20906Thread-1--------消费者------------产品...20906Thread-0---生产者---产品...20907Thread-1--------消费者------------产品...20907Thread-0---生产者---产品...20908Thread-1--------消费者------------产品...20908

2.2、多个生产者和多个消费者

package com.pb.thread.demo4;public class Product {  private String name;    private int count;    private boolean flag;      //生产  public synchronized void set(String name){    while(flag){ //修改为循环判断      try {        wait();      } catch (InterruptedException e) {        e.printStackTrace();      }    }    this.name=name+"..."+count++;    System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);    this.flag=true;    notifyAll(); //修改为notifyAll();  }  public synchronized void get(){    while(!flag){//修改为循环判断      try {        wait();      } catch (InterruptedException e) {        e.printStackTrace();      }    }    System.out.println(Thread.currentThread().getName()+"--------消费者------------"+name);    this.flag=false;    notifyAll();//修改为notifyAll();  }}

三、JDK 1.5新特性

一、Lock

Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。

public interface Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 

package com.pb.thread.demo4;import java.util.concurrent.locks.*;public class Product {  private String name;  private int count;  private boolean flag;  Lock lock = new ReentrantLock();// 声明锁对象  // 声明2个condition对象来表示生产者和消费都，如果有多个可以声明多个  // 显示声明  Condition condition_pro = lock.newCondition();// 生产者  Condition condition_con = lock.newCondition();  // 生产  public void set(String name) {    // 加锁    lock.lock();    try {      while (flag) { // 修改为循环判断        condition_pro.await(); // 指定对象锁睡觉      }      this.name = name + "..." + count++;      System.out.println(Thread.currentThread().getName() + "---生产者---" + this.name);      this.flag = true;      // 唤醒指定线程锁      condition_con.signal();// 唤醒消费都线程    } catch (InterruptedException e) {      e.printStackTrace();    } finally {      // 释放锁      lock.unlock();    }  }  public void get() {    // 加锁    lock.lock();    try {      while (!flag) {        //消费对象锁上        condition_con.await();      }      System.out.println(Thread.currentThread().getName() + "--------消费者------------" + name);      this.flag = false;      //唤醒生产者      condition_pro.signal();    } catch (InterruptedException e) {      e.printStackTrace();    } finally {      //释放锁      lock.unlock();    }  }}

四、线程常用方法

4.1、线程常用方法

五、守护线程和线程优先级

5.1、守护线程-后台资源

setDaemon
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。

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

该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。

参数：
on - 如果为 true，则将该线程标记为守护线程。
抛出：
IllegalThreadStateException - 如果该线程处于活动状态。
SecurityException - 如果当前线程无法修改该线程。

当前台线程都结束时，后台线程自动结束。

5.2、线程优先级

setPriority
public final void setPriority(int newPriority)更改线程的优先级。
首先调用线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException。

在其他情况下，线程优先级被设定为指定的 newPriority 和该线程的线程组的最大允许优先级相比较小的一个。

参数：
newPriority - 要为线程设定的优先级
抛出：
IllegalArgumentException - 如果优先级不在 MIN_PRIORITY 到 MAX_PRIORITY 范围内。

10-----1------------5

SecurityException - 如果当前线程无法修改该线程。

getPriority
public final int getPriority()返回线程的优先级。

返回：
该线程的优先级。

六、join线程

作用：阻塞指定的线程等到另一个线程完成以后，再继续执行

package com.pb.thread.demo2;public class MyThread implements Runnable {    @Override  public void run() {    for(int x=0;x<10;x++){      System.out.println(Thread.currentThread().getName()+"....."+x);    }  }}//=============package com.pb.thread.demo2;public class Demo {  public static void main(String[] args) {        MyThread my=new MyThread();    Thread t1=new Thread(my);    t1.setName("半路加入的线程");    for(int x=0;x<10;x++){      if(x==5){                try {          t1.start();          t1.join();        } catch (InterruptedException e) {          e.printStackTrace();        }            }            System.out.println(Thread.currentThread().getName()+"....."+x);    }  }}

结果：

main.....0main.....1main.....2main.....3main.....4半路加入的线程.....0半路加入的线程.....1半路加入的线程.....2半路加入的线程.....3半路加入的线程.....4半路加入的线程.....5半路加入的线程.....6半路加入的线程.....7半路加入的线程.....8半路加入的线程.....9main.....5main.....6main.....7main.....8main.....9

或者

package com.pb.thread.demo2;public class Test {  public static void main(String[] args) {    for(int x=0;x<10;x++){      if(x==5){              try {          Thread t1=new Thread(new MyThread(),"半路加入的线程");          t1.start();          t1.join();        } catch (InterruptedException e) {          e.printStackTrace();        }      }            System.out.println(Thread.currentThread().getName()+"....."+x);    }  }}

七、yield

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

package com.pb.thread.demo2;public class MyThread implements Runnable {    @Override  public void run() {    for(int x=0;x<10;x++){            System.out.println(Thread.currentThread().getName()+"....."+x);      Thread.yield();    }  }}//===========package com.pb.thread.demo2;public class Test {  public static void main(String[] args) {    new Thread(new MyThread(),"线程一").start();    new Thread(new MyThread(),"线程二").start();  }}

 八、停止线程

 开启多线程，运行代码通常是循环结构

只要控制住循环，就可以让run方法结束。也就是线程结束。

package com.pb.thread.demo4;public class StopThread implements Runnable {private boolean flag=true;  @Override  public void run() {    while(flag){      System.out.println(Thread.currentThread().getName()+"......run");    }  }  public void setChangeFlag(){    this.flag=false;  }  public static void main(String[] args) {     StopThread st=new StopThread();     Thread t1=new Thread(st);     Thread t2=new Thread(st);     t1.start();     t2.start();     int num=0;     while(true){       if(num++==60){         st.setChangeFlag();         break;               }       System.out.println(Thread.currentThread().getName()+"===="+num);     }  }}

interrupt

public void interrupt()

如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。  

package com.pb.thread.demo4;public class StopThread implements Runnable {  private boolean flag = true;  @Override  public synchronized void run() {    while (flag) {      try {        wait();      } catch (InterruptedException e) {        // e.printStackTrace();        System.out.println(Thread.currentThread().getName() + "......Exception");        flag = false; //设置标识为false      }      System.out.println(Thread.currentThread().getName() + "......run");    }  }  public void setChangeFlag() {    this.flag = false;  }  public static void main(String[] args) {    StopThread st = new StopThread();    Thread t1 = new Thread(st);    Thread t2 = new Thread(st);    t1.start();    t2.start();    int num = 0;    while (true) {      if (num++ == 60) {        //中断状态也就是冻结状态，回到运行状态        t1.interrupt();        t2.interrupt();        break;      }      System.out.println(Thread.currentThread().getName() + "====" + num);    }    System.out.println("over");  }}

main====1main====2main====3main====4main====5main====6main====7main====8main====9main====10main====11main====12main====13main====14main====15main====16main====17main====18main====19main====20main====21main====22main====23main====24main====25main====26main====27main====28main====29main====30main====31main====32main====33main====34main====35main====36main====37main====38main====39main====40main====41main====42main====43main====44main====45main====46main====47main====48main====49main====50main====51main====52main====53main====54main====55main====56main====57main====58main====59main====60overThread-1......ExceptionThread-1......runThread-0......ExceptionThread-0......run

九、sleep();

sleep

public static void sleep(long millis) throws InterruptedException

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

参数：

millis - 以毫秒为单位的休眠时间。

抛出：

InterruptedException - 如果任何线程中断了当前线程。当抛出该异常时，当前线程的中断状态 被清除。

 十、toString

toString

public String toString()

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

覆盖：

类 Object 中的 toString

返回：

该线程的字符串表示形式。

package com.pb.thread.demo4;public class StopThread implements Runnable {  private boolean flag = true;  @Override  public synchronized void run() {    while (flag) {          System.out.println(Thread.currentThread().toString()+ "......run");    }  }  public void setChangeFlag() {    this.flag = false;  }  public static void main(String[] args) {    StopThread st = new StopThread();    Thread t1 = new Thread(st);    Thread t2 = new Thread(st);    t1.start();    t2.start();    int num = 0;    while (true) {      if (num++ == 60) {        st.setChangeFlag();        break;      }      System.out.println(Thread.currentThread().toString()+ "====" + num);    }    System.out.println("over");  }}

Thread[Thread-0,5,main]......runThread[main,5,main]====1Thread[Thread-0,5,main]......runThread[main,5,main]====2Thread[Thread-0,5,main]......runThread[main,5,main]====3Thread[Thread-0,5,main]......runThread[main,5,main]====4Thread[main,5,main]====5Thread[main,5,main]====6Thread[main,5,main]====7Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====8Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====9Thread[Thread-0,5,main]......runThread[main,5,main]====10Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====11Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====12Thread[main,5,main]====13Thread[main,5,main]====14Thread[main,5,main]====15Thread[main,5,main]====16Thread[Thread-0,5,main]......runThread[main,5,main]====17Thread[main,5,main]====18Thread[main,5,main]====19Thread[main,5,main]====20Thread[main,5,main]====21Thread[main,5,main]====22Thread[main,5,main]====23Thread[main,5,main]====24Thread[main,5,main]====25Thread[main,5,main]====26Thread[main,5,main]====27Thread[main,5,main]====28Thread[main,5,main]====29Thread[main,5,main]====30Thread[main,5,main]====31Thread[main,5,main]====32Thread[main,5,main]====33Thread[main,5,main]====34Thread[main,5,main]====35Thread[main,5,main]====36Thread[main,5,main]====37Thread[main,5,main]====38Thread[main,5,main]====39Thread[main,5,main]====40Thread[main,5,main]====41Thread[main,5,main]====42Thread[main,5,main]====43Thread[main,5,main]====44Thread[main,5,main]====45Thread[main,5,main]====46Thread[main,5,main]====47Thread[main,5,main]====48Thread[main,5,main]====49Thread[main,5,main]====50Thread[main,5,main]====51Thread[main,5,main]====52Thread[main,5,main]====53Thread[main,5,main]====54Thread[main,5,main]====55Thread[main,5,main]====56Thread[main,5,main]====57Thread[main,5,main]====58Thread[main,5,main]====59Thread[main,5,main]====60overThread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......runThread[main,5,main]====1Thread[Thread-0,5,main]......runThread[main,5,main]====2Thread[Thread-0,5,main]......runThread[main,5,main]====3Thread[Thread-0,5,main]......runThread[main,5,main]====4Thread[main,5,main]====5Thread[main,5,main]====6Thread[main,5,main]====7Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====8Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====9Thread[Thread-0,5,main]......runThread[main,5,main]====10Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====11Thread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[Thread-0,5,main]......runThread[main,5,main]====12Thread[main,5,main]====13Thread[main,5,main]====14Thread[main,5,main]====15Thread[main,5,main]====16Thread[Thread-0,5,main]......runThread[main,5,main]====17Thread[main,5,main]====18Thread[main,5,main]====19Thread[main,5,main]====20Thread[main,5,main]====21Thread[main,5,main]====22Thread[main,5,main]====23Thread[main,5,main]====24Thread[main,5,main]====25Thread[main,5,main]====26Thread[main,5,main]====27Thread[main,5,main]====28Thread[main,5,main]====29Thread[main,5,main]====30Thread[main,5,main]====31Thread[main,5,main]====32Thread[main,5,main]====33Thread[main,5,main]====34Thread[main,5,main]====35Thread[main,5,main]====36Thread[main,5,main]====37Thread[main,5,main]====38Thread[main,5,main]====39Thread[main,5,main]====40Thread[main,5,main]====41Thread[main,5,main]====42Thread[main,5,main]====43Thread[main,5,main]====44Thread[main,5,main]====45Thread[main,5,main]====46Thread[main,5,main]====47Thread[main,5,main]====48Thread[main,5,main]====49Thread[main,5,main]====50Thread[main,5,main]====51Thread[main,5,main]====52Thread[main,5,main]====53Thread[main,5,main]====54Thread[main,5,main]====55Thread[main,5,main]====56Thread[main,5,main]====57Thread[main,5,main]====58Thread[main,5,main]====59Thread[main,5,main]====60overThread[Thread-0,5,main]......run

 十一、匿名内部类实现多线程

package com.pb.thread.demo4;/* * 匿名内部类实现多线程 */public class ThreadTest {  public static void main(String[] args) {    //线程对象    new Thread(){      public void run(){        for (int x = 0; x < 100; x++) {          System.out.println(Thread.currentThread().getName()+".........."+x);        }      }    }.start();    //Runnable 接口    Runnable r=new Runnable(){      public void run(){        for (int x = 0; x < 100; x++) {          System.out.println(Thread.currentThread().getName()+".........."+x);        }      }    };    //启动线程    new Thread(r).start();  }}

原标题：基础学习day12

关键词：