------- android培训、java培训、期待与您交流！
----------
线程间通讯：
其实就是多个线程在操作同一个资源，但是动作不同。
wait();
在其他线程调用此对象的notify()方法或notifyAll()方法，或者超过指定的时间量前，导致当前线程等待。
当前线程必须拥有此对象监视器。
notify();
唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。
选择是任意性的，并在对实现做出决定时发生。
线程通过调用其中一个
wait方法，在对象的监视器上等待。
notifyAll();
唤醒在此对象监视器上等待的所有线程。线程通过调用其中一个
wait方法，在对象的监视器上等待。
思考1：wait ( ),notify ( ),notifyAll ( ),用来操作线程为什么定义在了Object 类中？
1，这些方法存在与同步中。
2，使用这些方法时必须要标识所属的同步的锁。
3，锁可以是任意对象，所以任意对象调用的方法一定定义Object类中。
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。
思考2：wait ( ) ,sleep ( ) 有什么区别？
wait ( ) : 释放cpu执行权，释放锁。
sleep ( ) : 释放cpu执行权，不释放锁。
/**
*
* 多线程通讯示例：
* 多线程通讯就是多个线程共同操作同一个资源，但是动作不同
* 例：开启两个线程，交替输入输出两个人的名字和年龄
*
*/
public class ThreadTest
{
public static void main(String[] args)
{
Person p = new Person();
Input in = new Input(p);
Output out = new Output(p); Thread t1 = new Thread(in);
Thread t2 = new Thread(out); t1.start();
t2.start();
}
} //声明一个Person类，有两个属性，姓名和性别
class Person
{
String name;
String sex;
} //声明一个输入线程继承Runnable。传入名字和性别
class Input implements Runnable
{
private Person p; Input (Person p)
{
this.p = p;
} public void run()
{
int x = 0; while(true)
{
synchronized (p)
{
if (x==0)
{
p.name = "lilei";
p.sex = "boy";
}
else
{
p.name = "hanmeimei";
p.sex = "girl";
}
x = (1+x)%2;
}
}
}
} //声明一个输出线程的类继承Runnable,输出姓名和性别
class Output implements Runnable
{
private Person p; Output(Person p)
{
this.p = p;
} public void run()
{
while(true)
{
synchronized (p)
{
System.out.println("name: "+p.name+"-------sex: "+p.sex);
}
}
}
}
等待唤醒机制：
改进一下这个程序，让输入输出交替进行
/**
*
* 多线程通讯示例：
* 多线程通讯就是多个线程共同操作同一个资源，但是动作不同
* 例：开启两个线程，交替输入输出两个人的名字和年龄
*
*/
public class ThreadTest
{
public static void main(String[] args)
{
Person p = new Person();
Input in = new Input(p);
Output out = new Output(p); Thread t1 = new Thread(in);
Thread t2 = new Thread(out); t1.start();
t2.start();
}
} //声明一个Person类，有两个属性，姓名和性别
class Person
{
String name;
String sex;
boolean flat;
} //声明一个输入线程继承Runnable。传入名字和性别
class Input implements Runnable
{
private Person p; Input (Person p)
{
this.p = p;
} public void run()
{
int x = 0; while(true)
{
synchronized (p)
{
if (p.flat)
try{p.wait();}catch(Exception e){}
if (x==0)
{
p.name = "lilei";
p.sex = "boy";
}
else
{
p.name = "hanmeimei";
p.sex = "girl";
}
x = (1+x)%2;
p.flat = true;
p.notify();
}
}
}
} //声明一个输出线程的类继承Runnable,输出姓名和性别
class Output implements Runnable
{
private Person p; Output(Person p)
{
this.p = p;
} public void run()
{
while(true)
{
synchronized (p)
{
if (!p.flat)
try{p.wait();}catch(Exception e){}
System.out.println("name: "+p.name+"-------sex: "+p.sex);
p.flat = false;
p.notify();
}
}
}
}
发现有些数据不能被外界直接调用，具有安全隐患，所以改进如下：
/**
*
* 多线程通讯示例：
* 多线程通讯就是多个线程共同操作同一个资源，但是动作不同
* 例：开启两个线程，交替输入输出两个人的名字和年龄
*
*/
public class ThreadTest
{
public static void main(String[] args)
{
Person p = new Person();
Input in = new Input(p);
Output out = new Output(p); Thread t1 = new Thread(in);
Thread t2 = new Thread(out); t1.start();
t2.start();
}
} //声明一个Person类，有两个属性，姓名和性别
class Person
{
//私有数据，更安全
private String name;
private String sex;
private boolean flat; public synchronized void set(String name,String sex)
{
if (flat)
try{this.wait();}catch(Exception e){}
this.name = name;
this.sex = sex;
flat = true;
this.notify();
} public synchronized void out()
{
if (!flat)
try{this.wait();}catch(Exception e){}
System.out.println("name: "+name+"-------sex: "+sex);
flat = false;
this.notify();
}
} //声明一个输入线程继承Runnable。传入名字和性别
class Input implements Runnable
{
private Person p; Input (Person p)
{
this.p = p;
} public void run()
{
int x = 0; while(true)
{
if (x==0)
p.set("lilei","boy");
else
p.set("hanmeimei","girl");
x = (x+1)%2;
}
}
} //声明一个输出线程的类继承Runnable,输出姓名和性别
class Output implements Runnable
{
private Person p; Output(Person p)
{
this.p = p;
} public void run()
{
while(true)
{
p.out();
}
}
}
为什么定义notifyAll：
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
/**
*
* 当出现两个以上多线程进行多线程通讯的时候，需要用的notifyAll();
* 例子：
* 生产者消费者
*
*/
public class ProCusDemo
{
public static void main(String[] args)
{
Resource r = new Resource(); Pro p = new Pro(r);
Cus c = new Cus(r); Thread t1 = new Thread(p);
Thread t2 = new Thread(p);
Thread t3 = new Thread(c);
Thread t4 = new Thread(c); t1.start();
t2.start();
t3.start();
t4.start();
}
} //声明一个资源类，赋予基本属性
class Resource
{
private String name;
private int count = 1;
private boolean flat; public synchronized void set(String name)
{
while (flat)//用while让被唤醒的线程再一次判断标记
try{wait();}catch(Exception e){}
this.name = name+"-----"+count++; System.out.println(Thread.currentThread().getName()+"---生产者---"+this.name);
flat = true;
notifyAll();
} public synchronized void out()
{
while (!flat)//用while让被唤醒的线程再一次判断标记
try{wait();}catch(Exception e){} System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
flat = false;
notifyAll();
}
} class Pro implements Runnable
{
private Resource r; Pro(Resource r)
{
this.r = r;
} public void run()
{
while (true)
{
r.set("商品");
}
}
} class Cus implements Runnable
{
private Resource r; Cus(Resource r)
{
this.r = r;
} public void run()
{
while (true)
{
r.out();
}
}
}
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁进行获取。
该示例中，实现了本方只唤醒对方操作。
Lock:替代了Synchronized
lock
unlock
newCondition()
Condition：替代了Object wait notify notifyAll
await();
signal();
signalAll();
<span style="font-size:14px;">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(); }
} class Resource
{
private String name;
private int count = 1;
private boolean flag = false; 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();//释放锁的动作一定要执行。
}
} 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)
{
}
}
}
}
</span>
如何停止线程：
1. 定义循环结束标记，因为线程运行代码一般都是循环，只要控制了循环即可。
2. 注：stop方法已经过时不再使用。
stop方法已经过时，如何停止线程？
只有一种，run方法结束。开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。
特殊情况：当线程处于了冻结状态。就不会读取到标记。那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。使用interrupt（中断）方法。
该方法是结束线程的冻结状态，使线程回到运行状态中来。
<span style="font-size:14px;">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)
{
//st.changeFlag();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("over");
}
}
</span>
守护线程：
前台线程执行完之后后台线程自动执行完，主线程是前台线程。
<span style="font-size:14px;">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.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");
}
}
</span>
join用法：
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。
<span style="font-size:14px;">class Demo implements Runnable
{
public void run()
{
for(int x=0; x<70; x++)
{
System.out.println(Thread.currentThread().getName()+"...."+x);
}
}
} 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.join();//此时t1线程获得执行权，主线程冻结。
t2.start(); for(int x=0; x<80; x++)
{
System.out.println("main....."+x);
}
System.out.println("over");
}
}
</span>
yield() ：
可以稍微减缓程序运行，产生近似于交替运行的效果。
class Demo implements Runnable
{
public void run()
{
for(int x=0; x<70; x++)
{
System.out.println(Thread.currentThread().toString()+"....."+x);//toString()显示优先级，优先级1~10，默认5
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(); for(int x=0; x<80; x++)
{
System.out.println("main....."+x);
}
System.out.println("over");
}
}