进程：正在执行的程序，是一个动态的过程
线程：是进程中用于控制程序执行的控制单元(执行路径，执行情景)
进程中至少有一个线程。
在Java VM（java虚拟机）启动的时候会有一个进程java.exe.
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。
扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。
创建线程
创建线程的第一种方式：继承Thread类
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
目的：将自定义代码存储在run方法。让线程运行。
3，调用线程的start方法，
该方法两个作用：启动线程，调用run方法。
发现运行结果每一次都不同。因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行(多核除外)。cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行形容为在互相抢夺cpu的执行权。
这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。
为什么要覆盖run方法呢？
Thread类用于描述线程。该类就定义了一个功能，用于存储其他线程（非主线程）要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码。
创建线程的第二种方式：实现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方法。
线程中的方法
线程都有自己默认的名称：Thread-编号 该编号从0开始。
线程中的常用方法
static Thread currentThread():获取当前线程对象。
getName(): 获取线程名称。
设置线程名称：setName或者构造函数。
多线程中出现的问题
多线程的运行出现了安全问题。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行。导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块，方法如下
synchronized(对象)//任意对象都行
{
需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
必须保证同步中只能有一个线程在运行。
好处：解决了多线程的安全问题。
弊端：多个线程都需要判断锁，较为消耗资源，
示例代码如下：
public 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();
}
}
class Ticket implements Runnable {
private int tick = 100;
Object obj = new Object();// 为synchronized提供对象
public void run() {
while (true) {
synchronized (obj) {
if (tick > 0) {
try{Thread.sleep(50);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "....sale : " + tick--);
}
}
}
}
}
此段代码的是模拟卖票，假设有100张票，然后有4个线程同时卖票。
可以在Ticket类中有synchronized同步代码块，当有同步代码块时，持有synchronized同步锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取synchronized同步锁。线程将依序执行，也就是有一个线程在进入时，另一个线程无法进入。
如果没有synchronized同步锁，那么有可能会有以下问题产生，当tick剩下1张票的时候，t1现场进入了，然后遇到Thread.sleep(50)，失去执行权。
接着t2线程执行了了，此时tick仍然是1张票，因此t2也进入if语句，也遇到sleep()方法，失去了执行权。
然后t3线程也来了，遇到了与t1/t2一样的状况。
t4线程也既有可能遇到这种情况。
最后t1开始执行了，tick为0了。但是此时t2也在if语句中，也执行语句，tick就为-1，然后是t3/t4，导致了代码运行的结果出现了负数，与设想中的不同！
上面所描述的问题就是多线程中所要解决的问题，这也是synchronized同步锁的使用情景
同步锁
synchronized可以给代码块上锁，也可以给方法上锁，如下：
// 同步代码块
synchronized (对象) {
····· 代码块
}
// 同步方法
public synchronized void show (){}
那么问题来了，在同步代码块中我们可以很清楚的看到synchronized给哪一个对象上锁，那么同步方法又是给谁上锁呢？
同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用，就是this，所以同步函数使用的锁是this。
通过该程序进行验证。
使用两个线程来买票。一个线程在同步代码块中。一个线程在同步函数中。都在执行买票动作。
代码如下：
public class TicketDemo2 {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
// 让主线程休眠，将执行权移交给t1/t2线程
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
}
}
class Ticket implements Runnable {
private int tick = 100;
Object obj = new Object();
// 使用flag
boolean flag = true;
public void run() {
if (flag) {
while (true) {
// 使用的锁是obj
synchronized (obj) {
if (tick > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "....code : " + tick--);
}
}
}
} else
while (true)
show();
}
// 同步方法的锁对象是this，即所属对象的引用
public synchronized void show() {
if (tick > 0) {
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "....show.... : " + tick--);
}
}
}
上述代码中添加了同步方法，并且设置了flag布尔值，用以让线程能在中途从同步代码块中切换到同步方法中。
然后再控制台中看到结果：
Thread-1....show.... : 4
Thread-0....code : 3
Thread-1....show.... : 2
Thread-1....show.... : 1
Thread-0....code : 0
这里居然卖出了0张票，这明显是一个错误的结果，这是为什么呢？
答案在于我们虽然在多线程中使用了同步锁，但是我们的锁对象并不是同一个对象，因为在同步代码块中使用的是obj对象，如下：
synchronized (obj) {
·····代码省略
}
但是当obj替换成this的时候，我们就能输出正确的结果，不在输出0张票。
这足以证明在同步方法中使用的锁对象就是所属对象引用。
静态同步方法
static实际上也能使用同步锁，我们将上述代码修改，首先将同步方法修改为静态同步方法，然后将tick也标识为static，代码如下：
private static int tick = 100;
···
public static synchronized void show(){
····
}
调用方法跟前面一样。
这时再次输出了tick=0的错误结果！
这又是为什么呢？
这是因为静态方法中的同步锁对象使用的不是this，因为静态方法中也不可以定义this。
其原因在于静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
即 类名.class 该对象的类型是Class
静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class。
所以我们将同步代码块中的所对象修改为Ticket.class时就能输出正确结果，此时Ticket完整代码如下：
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(50);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "....code : " + tick--);
}
}
}
} else
while (true)
show();
}
// 静态方法的所对象是 类名.class
public static synchronized void show() {
if (tick > 0) {
try{Thread.sleep(50);}catch(Exception e){}
System.out.println(Thread.currentThread().getName() + "....show.... : " + tick--);
}
}
}
单例模式中的懒汉式
单例模式中的懒汉式写法其实颇为复杂，因为要考虑到多线程的问题。如果不添加synchronized进行同步，在多线程的情况下，仍有可能导致创建了多个单例的实例，这就违背了单例模式的设计出初衷，因此必须添加synchronized进行同步，正确写法如下：
class Single {
private static Single s = null;
private Single() {
}
public static Single getInstance() {
if (s == null) {
synchronized (Single.class) {
if (s == null)
s = new Single();
}
}
return s;
}
}
懒汉式与饿汉式的区别在于懒汉式用于延时加载。
而懒汉式出现的问题在于使用多线程的时候创建多个实例，这时可以使用同步解决。
使用synchronized同步也是有技巧的，如果使用同步方法也是可以的，代码如下：
public synchronized static Single getInstance() {
if (s == null) {
if (s == null)
s = new Single();
}
return s;
}
但这种写法会导致效率稍微低下，因此一般都采用双重判断的同步代码块的写法。
同时如果是使用了static静态符合，静态代码块所使用的同步锁为该类所属的字节码对象！
死锁
产生死锁的四个必要条件：
（1） 互斥条件：一个资源每次只能被一个进程使用。
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
同步中嵌套同步，但是它们之间的锁却不同，容易导致死锁，下面是死锁示例：
public DeadLockTest TicketDemo2 {
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 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();
}
在上面的例子中Test在t1线程中进入if语句得到了MyLock.locka的锁，然后进入了第二个代码块中需要MyLock.lockb的锁才能进行下一步。
但是此时t2线程也开始执行了，它先进入了Test中的else语句，获得了MyLock.locka的锁，需要MyLock.locka的所完成同步代码。
此时陷入了死局，t1持有了MyLock.locka的锁，但是无法获得MyLock.lockb的锁执行完线程，也无法释放MyLock.locka的锁。
而t2线程同样如此，持有MyLock.lockb的锁，但是无法获得MyLock.locka的锁执行完线程，也无法释放MyLock.locka的锁。
在写程序的时候应该避免死锁的产生。
线程间通信
线程间通讯： 其实就是多个线程在操作同一个资源，但是操作的动作不同。
wait:
notify();
notifyAll();
notify()方法用于唤醒等待中的线程，一般线程使用了wait()方法，会进入线程池中等待执行，此时使用notify()方法一般唤醒线程池中的第一个等待线程。
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程所持有的锁，
只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
多线程生产消费者示例
下列代码为正确示例：
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();
}
}
}
在多线程的情况下，通用的做法是使用while循环 + notifyAll()唤醒方法来判断执行代码。
而在单生产者和单消费者的情况下使用if循环 + notify()来判断执行代码。
首先分析一下使用if循环 + notify()在多生产者和多消费者中产生的问题，使用这种方法会导致程序执行两次生产，一次消费的情况，又或者是两次消费一次生产的情况。
关键代码如下：
public synchronized void set(String name)
{
if(flag)
try{this.wait();}catch(Exception e){}//t1(放弃资格) t2(获取资格)
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notify();
}
// t3 t4
public synchronized void out()
{
if(!flag)
try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
this.notify();
}
产生这种情况的原因在于如果生产者（t1/t2）先获得了执行权，此时flag为false，因此t1直接往下执行，生产出一个产品（执行println），然后将flag设为true，但是此时t1仍然能继续执行（本案例中线程没有退出机制，因此一旦执行将持续执行不停止），于是t1再次在if语句中判断，然而flag已经为true，所以t1执行了wait()方法，放弃执行权。
重点来了，在这个时候t2生产者，t3/t4消费者都有执行权，假设这时t2取得执行权，执行下去了，此时flag仍为true，因此t2也进如wait()阶段。
然后就轮到t3/t4执行了，他们消费一次之后，将flag设为false，然后唤醒了在线程池中的线程，而notify()会唤醒处于线程池中的第一个等待的线程，也就是t1。然而此时t3仍旧执行，但是遇到flag为false，于是t3执行了wait()方法。
这时线程中拥有执行权的就剩下生产者t1和消费者t4了，然而计算机执行了t4线程，因为flag为false的缘故，t4也等待了。
此时在线程池中等待的顺序依次为 t2，t3，t4。
t1开始执行了，然后把flag设置为true，并且执行了notify()方法，唤醒了t2线程。
但是之前t2已经通过了if的判断，处于wait()状态，因此被唤醒的时候不在执行if判断，直接往下执行，因此在t1之后也执行了生产命令。
最后唤醒了t3消费者，然后继续执行。
这就是联系两次执行了生产命令的原因。
上面说的有点啰嗦，但这非常重要，需要细细体会。
了解了为什么在多生产/消费者执行的情况下，使用if判断和notify()方法唤醒会持续执行两次生产或者消费的命令后，这是因为if只判断一次flag的情况，当线程被唤醒之后会直接往下执行的缘故。
那么我们如果使用while加上notify()方法，让线程每次被唤醒的时候都进行判断呢？
这时产生了死锁。
这个结束比较简单，首先t1运行，flag为true，然后t1继续执行的时候就进入wait()方法，如果此时t2执行的话，也进入wait()方法中。
然后t3/t4执行了，t3将flag设为false，并唤醒了t1，然后t3继续执行便执行了wait()方法，如果此时t4执行了，也会进入wait()方法中，这时消费者线程全灭
最后剩下t1在执行了，t1将flag设置true之后，唤醒了t2，但是此时flag为true，而每次唤醒都会在while进行一次循环，此时悲催的t2再次进入wait()方法，生产者线程也全灭了！
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
这就是产生死锁的原因。
所以在多生产多消费者的情况下使用while让每个线程在唤醒的时候再次进行判断，然后使用notifyAll()唤醒所有的线程，让每个线程再次做判断是否继续往下执行，这样才能确保每次都有线程能够执行，也能确保每个线程都能被唤醒，不会导致死锁。
使用jdk1.5之后的Lock接口进行同步
上面生产者和消费者的使用方法太过繁琐了，JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。该对象可以Lock锁 进行获取。
在下列示例中，实现了本方只唤醒对方操作。
Lock:替代了Synchronized
lock
unlock
newCondition()
Condition：替代了Object wait notify notifyAll
await();
signal();
signalAll();
我们修改上面生产者和消费者案例中的Resource的代码，将Synchronized替换为Lock，将notifyAll替换为Condition，代码如下：
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(); // 唤醒t3，t4中的一个
} 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) {
}
}
}
}
使用Condition的好处在于一个Lock锁可以拥有多个Condition对象。
而在上面的代码中定义了两个Condition对象，一个为生产者condition_pro的条件，另一个为消费者condition_con条件。
这使condition_pro可以使用自己的await()方法和condition_pro.signal()唤醒方法，这样就能让在生产者中唤醒消费者，而在消费者中唤醒生产者，不会发生像Synchornized中的那种唤醒了本方线程的失误事件。
但是要注意，使用Lock的时候，一定要在finally中释放锁，即调用lock.unlock()方法。
停止线程的方式
stop方法已经过时。
如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。
示例代码中给Runnable对象添加了flag标记，控制了while循环，代码如下：
class StopThreadDemo {
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.changeFlag();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName() + "......." + num);
}
System.out.println("over");
}
}
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;
}
}
特殊情况：
当线程处于了冻结状态。
就不会读取到标记。那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。Thread类提供该方法 interrupt();
示例如下：
class StopThread implements Runnable {
private boolean flag = true;
public synchronized void run() {
while (flag) {
try {
wait();
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + "....Exception");
flag = false;
}
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.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");
}
}
要注意的是使用 interrupt();方法并不是正确的停止线程的方式，而是以抛出异常的方式停止线程，要慎用。
Thread中的其他方法
setDaemon(boolean on) 将该线程标记为守护线程或用户线程。简单的说就是将线程设置为后台线程，此时将会与主线程抢夺CPU资源，而且主线程结束时，后台线程会自动结束。
修改上面的StopThreadDemo代码，将t1/t2线程设置为后台线程，如下
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) {
break;
}
System.out.println(Thread.currentThread().getName() + "......." + num);
}
System.out.println("over");
}
}
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;
}
}
此时并没有使用任何的方式结束线程，却发现当主线程结束时，t1/t2线程也结束了。
join()方法与yield()方法
join:
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。
join可以用来临时加入线程执行，代码示例：
class JoinDemo {
public static void main(String[] args) {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
t2.start();
for (int x = 0; x < 80; x++) {
System.out.println("main....."+x);
}
System.out.println("over");
}
}
class Demo implements Runnable {
public void run() {
for (int x = 0; x < 70; x++) {
System.out.println(Thread.currentThread().toString() + "....." + x);
}
}
}
toString():返回该线程的字符串你表示形式，包括线程名称、优先级和线程组
yield（）：暂停当前正在执行的线程对象，并执行其他线程，代码示例：
class YieldDemo {
public static void main(String[] args) {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
System.out.println("over");
}
}
class Demo implements Runnable {
public void run() {
for (int x = 0; x < 70; x++) {
System.out.println(Thread.currentThread().toString() + "....." + x);
Thread.yield();
}
}
}
线程间通讯
Java线程间通讯其实也就是使用Synchronized和Object类方法wait(),notify(),notifyAll()的共同使用，保证运行结果正确，这些都在上述代码有所涉及。