Java多线程技术 学习笔记
?
多线程?概述
?
/*
进程：是一个正在执行中的程序。
??每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
?
线程：就是进程中的一个独立的控制单元。
??线程在控制着进程的执行。
?
一个进程中至少有一个线程。
?
?
?
Java?VM??启动的时候会有一个进程java.exe.
?
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
?
扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。
?
?
?
1,如何在自定义的代码中，自定义一个线程呢？
?
通过对api的查找，java已经提供了对线程这类事物的描述。就Thread类。
?
创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
?目的：将自定义代码存储在run方法。让线程运行。
?
3，调用线程的start方法，
?该方法两个作用：启动线程，调用run方法。
?
?
?
发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。
?
这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。
?
?
?
为什么要覆盖run方法呢？
?
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。
?
也就是说Thread类中的run方法，用于存储线程要运行的代码。?
?
*/
?
class?Demo?extends?Thread
{
?public?void?run()
?{
??for(int?x=0;?x<60;?x++)
???System.out.println("demo?run----"+x);
?}
}
?
?
?
class?ThreadDemo?
{
?public?static?void?main(String[]?args)?
?{
??//for(int?x=0;?x<4000;?x++)
??//System.out.println("Hello?World!");
?
??Demo?d?=?new?Demo();//创建好一个线程。
??//d.start();//开启线程并执行该线程的run方法。
??d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。
?
??
??for(int?x=0;?x<60;?x++)
???System.out.println("Hello?World!--"+x);
???}
}
?
/*
练习：
创建两个线程，和主线程交替运行。
?
*/
?
?
?
?
线程运行?的?5种状态
?
?
?
?
?
?
?
获取线程对象?以及名称————?实现Runnable接口的方式?，解决卖票问题。
/*
需求：简单的卖票程序。
多个窗口同时买票。
创建线程的第二种方式：实现Runable接口
?
步骤：
1，定义类实现Runnable接口
2，覆盖Runnable接口中的run方法。
?将线程要运行的代码存放在该run方法中。
?
3，通过Thread类建立线程对象。
4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
?为什么要将Runnable接口的子类对象传递给Thread的构造函数。
?因为，自定义的run方法所属的对象是Runnable接口的子类对象。
?所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。?
?
实现方式和继承方式有什么区别呢？
?
实现方式好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。
?
两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。?
*/
?
class?Ticket?implements?Runnable//extends?Thread
{
?private??int?tick?=?100;
?public?void?run()
?{
??while(true)
??{
???if(tick>0)
???{
????System.out.println(Thread.currentThread().getName()+?tick--);
???}
??}
?}
}
?
class??TicketDemo
{
?public?static?void?main(String[]?args)?
?{
?
??Ticket?t?=?new?Ticket();
?
??Thread?t1?=?new?Thread(t,"窗口1????");//创建了一个线程；
??Thread?t2?=?new?Thread(t,"窗口2????");//创建了一个线程；
??Thread?t3?=?new?Thread(t,"窗口3????");//创建了一个线程；
??Thread?t4?=?new?Thread(t,"窗口4????");//创建了一个线程；
??t1.start();
??t2.start();
??t3.start();
??t4.start();
?
??/*
??Ticket?t1?=?new?Ticket();
??//Ticket?t2?=?new?Ticket();
??//Ticket?t3?=?new?Ticket();
??//Ticket?t4?=?new?Ticket();
?
??t1.start();
??t1.start();
??t1.start();
??t1.start();
??*/
?
?}
}
?
?
?
?
多线程?运行时的?安全问题——?synchronize同步代码块
/*
?
通过分析，发现，打印出0，-1，-2等错票。
?
多线程的运行出现了安全问题。
?
问题的原因：
?当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。
?
解决办法：
?对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
?
?
?
Java对于多线程的安全问题提供了专业的解决方式。
?
就是同步代码块。
?
synchronized(对象)
{
?需要被同步的代码
?
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
?
火车上的卫生间---经典。
?
同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
?
必须保证同步中只能有一个线程在运行。
?
好处：解决了多线程的安全问题。
?
弊端：多个线程需要判断锁，较为消耗资源，
?
*/
?
class?Ticket?implements?Runnable
{
?private??int?tick?=?1000;
?Object?obj?=?new?Object();
?public?void?run()
?{
??while(true)
??{
???synchronized(obj)
???{
????if(tick>0)
????{
?????try{Thread.sleep(10);}catch(Exception?e){}
?????System.out.println(Thread.currentThread().getName()+"....sale?:?"+?tick--);
????}
???}
??}
?}
}
?
class??TicketDemo2
{
?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();
?}
}
?
?
同步函数的锁?是?this
?
/*
同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
?
通过该程序进行验证。
?
使用两个线程来买票。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行买票动作。?
?
*/
class?Ticket?implements?Runnable
{
?private??int?tick?=?100;
?Object?obj?=?new?Object();
?boolean?flag?=?true;
?public??void?run()
?{
??if(flag)
??{
???while(true)
???{
????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()//this
?{
??if(tick>0)
??{
???try{Thread.sleep(10);}catch(Exception?e){}
???System.out.println(Thread.currentThread().getName()+"....show....?:?"+?tick--);
??}
?}
}
?
class??ThisLockDemo
{
?public?static?void?main(String[]?args)?
?{
?
??Ticket?t?=?new?Ticket();
?
??Thread?t1?=?new?Thread(t);
??Thread?t2?=?new?Thread(t);
??t1.start();
??try{Thread.sleep(10);}catch(Exception?e){}
??t.flag?=?false;
??t2.start();
?
?
?
//??Thread?t3?=?new?Thread(t);
//??Thread?t4?=?new?Thread(t);
//??t3.start();
//??t4.start();
?
?}
}
?
?
?
?
静态同步函数所用的锁是?该类的字节码?Class对象
?
/*
如果同步函数被静态修饰后，使用的锁是什么呢？
?
通过验证，发现不在是this。因为静态方法中也不可以定义this。
?
静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
类名.class??该对象的类型是Class
?
静态的同步方法，使用的锁是该方法所在类的字节码文件对象。?“当前类名.class”
?
注：在静态方法内部?使用?同步代码块时?使用锁对象?时??也?要使用静态的对象“当前类名.class”
?
*/
class?Ticket?implements?Runnable
{
?private?static??int?tick?=?100;
?//Object?obj?=?new?Object();
?boolean?flag?=?true;
?public??void?run()
?{
??if(flag)
??{
???while(true)
???{
????synchronized(Ticket.class)
????{
?????if(tick>0)
?????{
??????try{Thread.sleep(10);}catch(Exception?e){}
??????System.out.println(Thread.currentThread().getName()+"....code?:?"+?tick--);
?????}
????}
???}
??}
??else
???while(true)
????show();
?}
?public?static?synchronized?void?show()
?{
??if(tick>0)
??{
???try{Thread.sleep(10);}catch(Exception?e){}
???System.out.println(Thread.currentThread().getName()+"....show....?:?"+?tick--);
??}
?}
}
?
class??StaticMethodDemo
{
?public?static?void?main(String[]?args)?
?{
?
??Ticket?t?=?new?Ticket();
?
??Thread?t1?=?new?Thread(t);
??Thread?t2?=?new?Thread(t);
??t1.start();
??try{Thread.sleep(10);}catch(Exception?e){}
??t.flag?=?false;
??t2.start();
?
?}
}
?
?
?
?
单例设计模式——懒汉式
?
/*
单例设计模式。
注：因饿汉式??单例不存在?多线程安全的问题，建议多使用
????而懒汉式，??因存在多线程安全的问题，所以需要使用“同步代码块+双重校验”的方式来解决
*/
//饿汉式。
?
/*
class?Single
{
?private?static?final?Single?s?=?new?Single();
?private?Single(){}
?public?static?Single?getInstance()
?{
??return?s;
?}
}
*/
?
//懒汉式：特点是实例对象的延迟加载。重要的面试题。
?
class?Single
{
?private?static?Single?s?=?null;
?private?Single(){}
?
?public?static??Single?getInstance()
?{
??if(s==null)
??{
???synchronized(Single.class)
???{
????if(s==null)
?????//--->A;
?????s?=?new?Single();
???}
??}
??return?s;
?}
}
?
class?SingleDemo?
{
?public?static?void?main(String[]?args)?
?{
??System.out.println("Hello?World!");
?}
}
?
?
?
?
多线程?————?死锁
?
?
?
class?Test?implements?Runnable
{
?private?boolean?flag;
?Test(boolean?flag)
?{
??this.flag?=?flag;
?}
?
?public?void?run()
?{
??if(flag)
??{
???while(true)
???{
????synchronized(MyLock.locka)
????{
?????System.out.println(Thread.currentThread().getName()+"...if?locka?");
?????synchronized(MyLock.lockb)
?????{
??????System.out.println(Thread.currentThread().getName()+"..if?lockb");?????
?????}
????}
???}
??}
??else
??{
???while(true)
???{
????synchronized(MyLock.lockb)
????{
?????System.out.println(Thread.currentThread().getName()+"..else?lockb");
?????synchronized(MyLock.locka)
?????{
??????System.out.println(Thread.currentThread().getName()+".....else?locka");
?????}
????}
???}
??}
?}
}
?
class?MyLock
{
?static?Object?locka?=?new?Object();
?static?Object?lockb?=?new?Object();
}
?
class??DeadLockTest
{
?public?static?void?main(String[]?args)?
?{
??Thread?t1?=?new?Thread(new?Test(true));
??Thread?t2?=?new?Thread(new?Test(false));
??t1.start();
??t2.start();
?}
}
?
?
?
?
?
?
线程间通信?——?解决安全问题：等待唤醒机制
?
/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。
?
*/
class?Res
{
?String?name;
?String?sex;
?boolean?flag?=?false;
}
?
class?Input?implements?Runnable
{
?private?Res?r?;
?Input(Res?r)
?{
??this.r?=?r;
?}
?public?void?run()
?{
??int?x?=?0;
??while(true)
??{
???synchronized(r)
???{
?
????if(r.flag)
?????try{r.wait();}catch(Exception?e){}
????if(x==0)
????{
?????r.name="mike";
?????r.sex="man";
????}
????else
????{
?????r.name="丽丽";
?????r.sex?=?"女女女女女";
????}
????x?=?(x+1)%2;
????r.flag?=?true;
????r.notify();
???}
??}
?}
}
?
class?Output?implements?Runnable
{
?private?Res?r?;
?
?Output(Res?r)
?{
??this.r?=?r;
?}
?public?void?run()
?{
??while(true)
??{
???synchronized(r)
???{
????if(!r.flag)
?????try{r.wait();}catch(Exception?e){}
????System.out.println(r.name+"...."+r.sex);
????r.flag?=?false;
????r.notify();
???}
??}
?}
}
?
class??InputOutputDemo
{
?public?static?void?main(String[]?args)?
?{
??Res?r?=?new?Res();
?
??Input?in?=?new?Input(r);
??Output?out?=?new?Output(r);
?
??Thread?t1?=?new?Thread(in);
??Thread?t2?=?new?Thread(out);
?
??t1.start();
??t2.start();
?}
}
?
//notifyAll();
?
/*
wait:
notify();
notifyAll();
?
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
?
为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
?
也就是说，等待和唤醒必须是同一个锁。
?
而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
*/
?
?
?
?
上述代码优化处理
?
/*
线程间通讯：
其实就是多个线程在操作同一个资源，
但是操作的动作不同。
?
*/
class?Res
{
?private?String?name;
?private?String?sex;
?private?boolean?flag?=?false;
?
?public?synchronized?void?set(String?name,String?sex)
?{
??if(flag)
???try{this.wait();}catch(Exception?e){}
??this.name?=?name;
??
??this.sex?=?sex;
??flag?=?true;
??this.notify();
?}
?public?synchronized?void?out()
?{
??if(!flag)
???try{this.wait();}catch(Exception?e){}
??System.out.println(name+"........"+sex);
??flag?=?false;
??this.notify();
?}
}
?
class?Input?implements?Runnable
{
?private?Res?r?;
?Input(Res?r)
?{
??this.r?=?r;
?}
?public?void?run()
?{
??int?x?=?0;
??while(true)
??{
???if(x==0)????
????r.set("mike","man");????
???else?
????r.set("丽丽","女女女女女");????
???x?=?(x+1)%2;
??}
?}
}
?
class?Output?implements?Runnable
{
?private?Res?r?;
?
?Output(Res?r)
?{
??this.r?=?r;
?}
?public?void?run()
?{
??while(true)
??{
???r.out();
??}
?}
}
?
class??InputOutputDemo2
{
?public?static?void?main(String[]?args)?
?{
??Res?r?=?new?Res();
?
??new?Thread(new?Input(r)).start();
??new?Thread(new?Output(r)).start();
??/*
??Input?in?=?new?Input(r);
??Output?out?=?new?Output(r);
?
??Thread?t1?=?new?Thread(in);
??Thread?t2?=?new?Thread(out);
?
??t1.start();
??t2.start();
??*/
?}
}
?
?
?
?
?
?
线程间通信——多个并发线程的生产者和消费者?（经典示例）?
?
class?ProducerConsumerDemo?
{
?public?static?void?main(String[]?args)?
?{
??Resource?r?=?new?Resource();
?
??Producer?pro?=?new?Producer(r);
??Consumer?con?=?new?Consumer(r);
?
??Thread?t1?=?new?Thread(pro);
??Thread?t2?=?new?Thread(pro);
??Thread?t3?=?new?Thread(con);
??Thread?t4?=?new?Thread(con);
?
??t1.start();
??t2.start();
??t3.start();
??t4.start();
?
?}
}
?
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。
?
为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
?
*/
?
class?Resource
{
?private?String?name;
?private?int?count?=?1;
?private?boolean?flag?=?false;
???//??t1????t2
?public?synchronized?void?set(String?name)
?{
??while(flag)
???try{this.wait();}catch(Exception?e){}//t1(放弃资格)??t2(获取资格)
??this.name?=?name+"--"+count++;
?
??System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
??flag?=?true;
??this.notifyAll();
?}
?
?//??t3???t4??
?public?synchronized?void?out()
?{
??while(!flag)
???try{wait();}catch(Exception?e){}//t3(放弃资格)?t4(放弃资格)
??System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
??flag?=?false;
??this.notifyAll();
?}
}
?
class?Producer?implements?Runnable
{
?private?Resource?res;
?
?Producer(Resource?res)
?{
??this.res?=?res;
?}
?public?void?run()
?{
??while(true)
??{
???res.set("+商品+");
??}
?}
}
?
class?Consumer?implements?Runnable
{
?private?Resource?res;
?
?Consumer(Resource?res)
?{
??this.res?=?res;
?}
?public?void?run()
?{
??while(true)
??{
???res.out();
??}
?}
}
?
?
?
?
?
?
线程间通信——多个并发线程的?生产者和消费者——JDK5.0?升级版：Lock?和?Condition?
?
?
?
import?java.util.concurrent.locks.*;
?
class?ProducerConsumerDemo2?
{
?public?static?void?main(String[]?args)?
?{
??Resource?r?=?new?Resource();
?
??Producer?pro?=?new?Producer(r);
??Consumer?con?=?new?Consumer(r);
?
??Thread?t1?=?new?Thread(pro);
??Thread?t2?=?new?Thread(pro);
??Thread?t3?=?new?Thread(con);
??Thread?t4?=?new?Thread(con);
?
??t1.start();
??t2.start();
??t3.start();
??t4.start();
?
?}
}
?
/*
JDK1.5?中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify?notifyAll，替换了Condition对象。
该对象可以Lock锁?进行获取。
该示例中，实现了本方只唤醒对方操作。
?
Lock:替代了Synchronized
?lock?
?unlock
?newCondition()
?
Condition：替代了Object?wait?notify?notifyAll
?await();
?signal();
?signalAll();
*/
class?Resource
{
?private?String?name;
?private?int?count?=?1;
?private?boolean?flag?=?false;
???//??t1????t2
?private?Lock?lock?=?new?ReentrantLock();
?
?private?Condition?condition_pro?=?lock.newCondition();
?private?Condition?condition_con?=?lock.newCondition();
?
?
?
?public??void?set(String?name)throws?InterruptedException
?{
??lock.lock();
??try
??{
???while(flag)
????condition_pro.await();//t1,t2
???this.name?=?name+"--"+count++;
?
???System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
???flag?=?true;
???condition_con.signal();
??}
??finally
??{
???lock.unlock();//释放锁的动作一定要执行。
??}
?}
?
?//??t3???t4??
?public??void?out()throws?InterruptedException
?{
??lock.lock();
??try
??{
???while(!flag)
????condition_con.await();
???System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
???flag?=?false;
???condition_pro.signal();
??}
??finally
??{
???lock.unlock();
??}
??
?}
}
?
class?Producer?implements?Runnable
{
?private?Resource?res;
?
?Producer(Resource?res)
?{
??this.res?=?res;
?}
?public?void?run()
?{
??while(true)
??{
???try
???{
????res.set("+商品+");
???}
???catch?(InterruptedException?e)
???{
???}
???
??}
?}
}
?
class?Consumer?implements?Runnable
{
?private?Resource?res;
?
?Consumer(Resource?res)
?{
??this.res?=?res;
?}
?public?void?run()
?{
??while(true)
??{
???try
???{
????res.out();
???}
???catch?(InterruptedException?e)
???{
???}
??}
?}
}
?
?
?
?
?
?
多线程————停止线程
?
?
?
/*
stop方法已经过时。
?
如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。
?
只要控制住循环，就可以让run方法结束，也就是线程结束。
?
特殊情况：
当线程处于了冻结状态。
就不会读取到标记。那么线程就不会结束。
?
当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。
?
Thread类提供该方法?interrupt();
?
?
?
*/
class?StopThread?implements?Runnable
{
?private?boolean?flag?=true;
?public??void?run()
?{
??while(flag)
??{
???
???System.out.println(Thread.currentThread().getName()+"....run");
??}
?}
?public?void?changeFlag()
?{
??flag?=?false;
?}
}
?
?
?
class??StopThreadDemo
{
?public?static?void?main(String[]?args)?
?{
??StopThread?st?=?new?StopThread();
??
??Thread?t1?=?new?Thread(st);
??Thread?t2?=?new?Thread(st);
?
??t1.setDaemon(true);
??t2.setDaemon(true);
??t1.start();
??t2.start();
?
??int?num?=?0;
?
??while(true)
??{
???if(num++?==?60)
???{
????//st.changeFlag();
????//t1.interrupt();
????//t2.interrupt();
????break;
???}
???System.out.println(Thread.currentThread().getName()+"......."+num);
??}
??System.out.println("over");
?}
}
?
?
?
?
?
?
守护线程?Join?/?线程优先级??/??yield?方法
?
/*
join:
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。
?
join可以用来临时加入线程执行。
?
线程优先级?//t1.setPriority(Thread.MAX_PRIORITY);?
?
yield（）方法：主要是用来暂时出让一次CPU执行权，可实现隔次执行?交替的效果。
*/
?
class?Demo?implements?Runnable
{
?public?void?run()
?{
??for(int?x=0;?x<70;?x++)
??{
???System.out.println(Thread.currentThread().toString()+"....."+x);
???Thread.yield();
??}
?}
}
?
class??JoinDemo
{
?public?static?void?main(String[]?args)?throws?Exception
?{
??Demo?d?=?new?Demo();
??Thread?t1?=?new?Thread(d);
??Thread?t2?=?new?Thread(d);
??t1.start();
??
??//t1.setPriority(Thread.MAX_PRIORITY);
?
??t2.start();
?
??//t1.join();
?
??for(int?x=0;?x<80;?x++)
??{
???//System.out.println("main....."+x);
??}
??System.out.println("over");
?}
}
?
?
多线程在实际应用中的演示
?
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();
??
?
??for(int?x=0;?x<100;?x++)
??{
???System.out.println(Thread.currentThread().getName()+"....."+x);
??}
?
??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();
?
??//new?Test1().start();
?}
}
/*
class?Test1?extends?Thread
{
?public?void?run()
?{
??for(int?x=0;?x<100;?x++)
??{
???System.out.println(Thread.currentThread().getName()+"....."+x);
??}
?}
}
*/
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?