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

王朝学院·作者佚名 2016-08-27

宽屏版字体: 小 | 中 | 大 | 超大

一、线程之间的通信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

packagecom.pb.thread.demo1;publicclassDemo {PRivateintnum=1;/** 打印偶数*/publicsynchronizedvoidput(){if(num%2==0){try{

wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

notify();

System.out.println(Thread.currentThread().getName()+","+num);

num++;

}/** 打印奇数*/publicsynchronizedvoidget(){if(num%2!=0){try{//当前线程等待wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

}//唤醒另一等待中的线程notify();

System.out.println(Thread.currentThread().getName()+","+num);

num++;

}publicintgetNum() {returnnum;

}publicvoidsetNum(intnum) {this.num =num;

}

packagecom.pb.thread.demo1;/*** 打印偶数

*@authordenny

**/publicclassAimplementsRunnable {

Demo demo;publicA(Demo demo){this.demo=demo;

}

@Overridepublicvoidrun() {while(demo.getNum()<100){

demo.put();

}

}packagecom.pb.thread.demo1;/*** 打印奇数

*@authordenny

**/publicclassBimplementsRunnable {

Demo demo;publicB(Demo demo) {this.demo =demo;

}

@Overridepublicvoidrun() {while(demo.getNum()<100){

demo.get();

}

测试类

packagecom.pb.thread.demo1;/*** 2个线程交替打印1-100

*@authordenny

**/publicclassTest {publicstaticvoidmain(String[] args) {

Demo demo=newDemo();

A a=newA(demo);

B b=newB(demo);

Thread t1=newThread(a);

Thread t2=newThread(b);

t1.start();

t2.start();

}

结果：

Picked upjava_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

交替打印

一个输入，一个输出

packagecom.pb.thread.demo3;/***

*@authorDenny

* 线程间通讯：

* 其它就是多个线程在操作同一个资源

* 只是操作的动作不同

**/publicclassPerson {privateString name;privateintage;privateString gender;privatebooleanflag=false;publicString getName() {returnname;

}publicvoidsetName(String name) {this.name =name;

}publicintgetAge() {returnage;

}publicvoidsetAge(intage) {this.age =age;

}publicString getGender() {returngender;

}publicvoidsetGender(String gender) {this.gender =gender;

}publicbooleangetFlag() {returnflag;

}publicvoidsetFlag(booleanflag) {this.flag =flag;

}

}//======================packagecom.pb.thread.demo3;publicclassInputimplementsRunnable {privatePerson person;publicInput(Person person) {this.person =person;

}

@Overridepublicvoidrun() {intx = 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();

}

}publicPerson getPerson() {returnperson;

}publicvoidsetPerson(Person person) {this.person =person;

}

}//=======================packagecom.pb.thread.demo3;publicclassOutputimplementsRunnable {privatePerson person;publicOutput(Person person) {this.person =person;

}

@Overridepublicvoidrun() {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();

}

}publicPerson getPerson() {returnperson;

}publicvoidsetPerson(Person person) {this.person =person;

}

}//====================packagecom.pb.thread.demo3;/***

*@authorDenny

*wait(),notify(),notifyAll()

*都使用在同步中，因为要对持胡监视器（锁）的线程操作

*因为只有同步才有锁

*为什么这些操作线程的方法要定义在Object类中呢？

*国为这些方法在操作线程时，都必须要标识它们所操作作线程只有的锁

*只有同一个锁上的被等待，可以被同一个锁上的notify()唤醒

*不可以对不同锁中的线程唤醒

*等待和唤醒必须是同一个锁。

*锁可以是任意对象，可以被任意对象调用的方法在Object中.*/publicclassTest {publicstaticvoidmain(String[] args) {

Person person=newPerson();

Input input=newInput(person);

Output output=newOutput(person);

Thread t1=newThread(input);

Thread t2=newThread(output);

t1.start();

t2.start();

}

优化以上代码

packagecom.pb.thread.demo3;/***

*@authorDenny

* 线程间通讯：

* 其它就是多个线程在操作同一个资源

* 只是操作的动作不同

**/publicclassPerson {privateString name;privateintage;privateString gender;privatebooleanflag;publicsynchronizedvoidsetThis(String name,intage,String gender){if(flag){try{

wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

}this.name=name;this.age=age;this.gender=gender;this.flag=true;

notify();

}publicsynchronizedvoidgetThis(){if(!flag){try{

wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println("姓名：" +this.name + "年龄:" +this.age + ",性别：" +this.gender);this.flag=false;

notify();

}publicString getName() {returnname;

}publicvoidsetName(String name) {this.name =name;

}publicintgetAge() {returnage;

}publicvoidsetAge(intage) {this.age =age;

}publicString getGender() {returngender;

}publicvoidsetGender(String gender) {this.gender =gender;

}publicbooleangetFlag() {returnflag;

}publicvoidsetFlag(booleanflag) {this.flag =flag;

}

}//====================packagecom.pb.thread.demo3;publicclassInputimplementsRunnable {privatePerson person;publicInput(Person person) {this.person =person;

}

@Overridepublicvoidrun() {intx = 0;while(true) {if(x == 0) {

person.setThis("jony", 33,"man");

}else{

person.setThis("李丽", 23,"女");

}

x= (x + 1) % 2;

}

}publicPerson getPerson() {returnperson;

}publicvoidsetPerson(Person person) {this.person =person;

}

}//========================packagecom.pb.thread.demo3;publicclassOutputimplementsRunnable {privatePerson person;publicOutput(Person person) {this.person =person;

}

@Overridepublicvoidrun() {while(true) {

person.getThis();

}

}publicPerson getPerson() {returnperson;

}publicvoidsetPerson(Person person) {this.person =person;

}

}//=================packagecom.pb.thread.demo3;/***

*@authorDenny

*wait(),notify(),notifyAll()

*都使用在同步中，因为要对持胡监视器（锁）的线程操作

*因为只有同步才有锁

*为什么这些操作线程的方法要定义在Object类中呢？

*国为这些方法在操作线程时，都必须要标识它们所操作作线程只有的锁

*只有同一个锁上的被等待，可以被同一个锁上的notify()唤醒

*不可以对不同锁中的线程唤醒

*等待和唤醒必须是同一个锁。

*锁可以是任意对象，可以被任意对象调用的方法在Object中.*/publicclassTest {publicstaticvoidmain(String[] args) {

Person person=newPerson();newThread(newInput(person)).start();newThread(newOutput(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、单个生产者和单个消费者

packagecom.pb.thread.demo4;publicclassProduct {privateString name;privateintcount;privatebooleanflag;//生产publicsynchronizedvoidset(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();

}publicsynchronizedvoidget(){if(!flag){try{

wait();

}catch(InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName()+"--------消费者------------"+name);this.flag=false;

notify();

}

}//======================packagecom.pb.thread.demo4;publicclassProducterimplementsRunnable {privateProduct product;publicProducter(Product product){this.product=product;

}

@Overridepublicvoidrun() {while(true){

product.set("产品");

}

}//================packagecom.pb.thread.demo4;publicclassConsumerimplementsRunnable {privateProduct product;publicConsumer(Product product){this.product=product;

}

@Overridepublicvoidrun() {while(true){

product.get();

}

}//================packagecom.pb.thread.demo4;publicclassTest {publicstaticvoidmain(String[] args) {

Product p=newProduct();

Producter producter=newProducter(p);

Consumer consumer=newConsumer(p);

Thread t1=newThread(producter);

Thread t2=newThread(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、多个生产者和多个消费者

packagecom.pb.thread.demo4;publicclassProduct {privateString name;privateintcount;privatebooleanflag;//生产publicsynchronizedvoidset(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();}publicsynchronizedvoidget(){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 interfaceCondition

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

packagecom.pb.thread.demo4;importjava.util.concurrent.locks.*;publicclassProduct {privateString name;privateintcount;privatebooleanflag;

Lock lock=newReentrantLock();//声明锁对象//声明2个condition对象来表示生产者和消费都，如果有多个可以声明多个//显示声明Condition condition_pro = lock.newCondition();//生产者Condition condition_con =lock.newCondition();//生产publicvoidset(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();

}

}publicvoidget() {//加锁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、线程常用方法

No.

方法名称

类型

描述

public Thread(Runnable target)

构造

接收Runnable接口子类对象，实例化Thread对象

public Thread(Runnable target,String name)

构造

接收Runnable接口子类对象，实例化Thread对象，并设置线程名称

public Thread(String name)

构造

实例化Thread对象，并设置线程名称

public static Thread currentThread()

普通

返回目前正在执行的线程

public final String getName()

普通

返回线程的名称

public final int getPriority()

普通

发挥线程的优先级

public boolean isInterrupted()

普通

判断目前线程是否被中断，如果是，返回true，否则返回false

public final boolean isAlive()

普通

判断线程是否在活动，如果是，返回true，否则返回false

public final void join() throws InterruptedException

普通

等待线程死亡

public final synchronized void join(long millis) throws InterruptedException

普通

等待millis毫秒后，线程死亡

public void run()

普通

执行线程

public final void setName(String name)

普通

设定线程名称

public final void setPriority(int newPriority)

普通

设定线程的优先值

public static void sleep(long millis) throws InterruptedException

普通

使目前正在执行的线程休眠millis毫秒

public void start()

普通

开始执行线程

public static void yield()

普通

将目前正在执行的线程暂停，允许其它线程执行

public final void setDaemon(boolean on)

普通

将一个线程设置成后台运行

public final void setPriority(int newPriority)

普通

更改线程的优先级

五、守护线程和线程优先级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

static int

MAX_PRIORITY

线程可以具有的最高优先级。

static int

MIN_PRIORITY

线程可以具有的最低优先级。

static int

NORM_PRIORITY

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

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

getPriority

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

该线程的优先级。

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

packagecom.pb.thread.demo2;publicclassMyThreadimplementsRunnable {

@Overridepublicvoidrun() {for(intx=0;x<10;x++){

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

}

}//=============packagecom.pb.thread.demo2;publicclassDemo {publicstaticvoidmain(String[] args) {

MyThread my=newMyThread();

Thread t1=newThread(my);

t1.setName("半路加入的线程");for(intx=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

或者

packagecom.pb.thread.demo2;publicclassTest {publicstaticvoidmain(String[] args) {for(intx=0;x<10;x++){if(x==5){try{

Thread t1=newThread(newMyThread(),"半路加入的线程");

t1.start();

t1.join();

}catch(InterruptedException e) {

e.printStackTrace();

}

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

}

七、yield

yield

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

packagecom.pb.thread.demo2;publicclassMyThreadimplementsRunnable {

@Overridepublicvoidrun() {for(intx=0;x<10;x++){

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

Thread.yield();

}

}//===========packagecom.pb.thread.demo2;publicclassTest {publicstaticvoidmain(String[] args) {newThread(newMyThread(),"线程一").start();newThread(newMyThread(),"线程二").start();

}

八、停止线程

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

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

packagecom.pb.thread.demo4;publicclassStopThreadimplementsRunnable {privatebooleanflag=true;

@Overridepublicvoidrun() {while(flag){

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

}

}publicvoidsetChangeFlag(){this.flag=false;

}publicstaticvoidmain(String[] args) {

StopThread st=newStopThread();

Thread t1=newThread(st);

Thread t2=newThread(st);

t1.start();

t2.start();intnum=0;while(true){if(num++==60){

st.setChangeFlag();

break;

}

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

}

interrupt

public voidinterrupt()

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

packagecom.pb.thread.demo4;publicclassStopThreadimplementsRunnable {privatebooleanflag =true;

@Overridepublicsynchronizedvoidrun() {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");

}

}publicvoidsetChangeFlag() {this.flag =false;

}publicstaticvoidmain(String[] args) {

StopThread st=newStopThread();

Thread t1=newThread(st);

Thread t2=newThread(st);

t1.start();

t2.start();intnum = 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====60over

Thread-1......Exception

Thread-1......run

Thread-0......Exception

Thread-0......run

九、sleep();

sleep

public static voidsleep(long millis) throws InterruptedException

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

参数：

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

抛出：

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

十、toStringtoString

public StringtoString()

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

覆盖：类Object中的toString返回：该线程的字符串表示形式。

packagecom.pb.thread.demo4;publicclassStopThreadimplementsRunnable {privatebooleanflag =true;

@Overridepublicsynchronizedvoidrun() {while(flag) {

System.out.println(Thread.currentThread().toString()+ "......run");

}

}publicvoidsetChangeFlag() {this.flag =false;

}publicstaticvoidmain(String[] args) {

StopThread st=newStopThread();

Thread t1=newThread(st);

Thread t2=newThread(st);

t1.start();

t2.start();intnum = 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]......run

Thread[main,5,main]====1Thread[Thread-0,5,main]......run

Thread[main,5,main]====2Thread[Thread-0,5,main]......run

Thread[main,5,main]====3Thread[Thread-0,5,main]......run

Thread[main,5,main]====4Thread[main,5,main]====5Thread[main,5,main]====6Thread[main,5,main]====7Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====8Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====9Thread[Thread-0,5,main]......run

Thread[main,5,main]====10Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====11Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====12Thread[main,5,main]====13Thread[main,5,main]====14Thread[main,5,main]====15Thread[main,5,main]====16Thread[Thread-0,5,main]......run

Thread[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]====60over

Thread[Thread-0,5,main]......run

Thread[main,5,main]====1Thread[Thread-0,5,main]......run

Thread[main,5,main]====2Thread[Thread-0,5,main]......run

Thread[main,5,main]====3Thread[Thread-0,5,main]......run

Thread[main,5,main]====4Thread[main,5,main]====5Thread[main,5,main]====6Thread[main,5,main]====7Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====8Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====9Thread[Thread-0,5,main]......run

Thread[main,5,main]====10Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====11Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

Thread[main,5,main]====12Thread[main,5,main]====13Thread[main,5,main]====14Thread[main,5,main]====15Thread[main,5,main]====16Thread[Thread-0,5,main]......run

Thread[Thread-0,5,main]......run

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

packagecom.pb.thread.demo4;/** 匿名内部类实现多线程*/publicclassThreadTest {publicstaticvoidmain(String[] args) {//线程对象newThread(){publicvoidrun(){for(intx = 0; x < 100; x++) {

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

}

}.start();//Runnable 接口Runnable r=newRunnable(){publicvoidrun(){for(intx = 0; x < 100; x++) {

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

}

};//启动线程newThread(r).start();

}