关键字:线程;等待唤醒机制;锁;线程优先级;
1、jdk1.5中,提供了,许多县城升级解决方案,将同步 synchrozed 替换成 显示 Lock 操作
将 object 中的 wait ,notify,notifyAll,替换成了condition 对象。
该对象可以 Lock锁,进行获取
2、该实例中,实现了,本方置换型对方的操作。
stop方法已经过时。
如何停止线程?
只有一种,润方法结束
开启多线程运行,运行代码通常是循环结构。
只要控制循环,就可以让run方法结束,也就是线程结束
当线程处于冻结状态,就不会读取到标记,那么线程就不会结束
当没有指定的方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除。
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束
Thread类提供该方法, interrupt();
对象.setDemo(true) 如果主线程结束,则这个线程自动结束
一、线程间的通信
其实就是多个线程在操作同一个资源,就是操作的动作不同。
二、等待唤醒机制
1、wait(),notify(),notifyAll(),都使用在同步中,因为要对持有监视器(锁)的线程操作。所以要使用在同步中,因为只有同步才具有锁。
2、为什么这些操作线程的方法要定义Object类中呢?因为这些方法在操作同步中,线程,都必须要表示它们所操作线程只有的锁,只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒,不可以对不同锁中的线程进行唤醒。也就是说,等待和唤醒必须是同一个锁。
3、而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。
/*
线程间通讯:
其实就是多个线程在操作同一个资源,
但是操作的动作不同。
*/
import java.lang.*;
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();
}
}
}
}
public class Demo{
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();
}
}
代码优化:
class Res{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex){
if(this.flag){
try{ this.wait();}catch(Exception e){}
}
this.name = name;
this.sex = sex;
this.flag = true;
this.notify();
}
public synchronized void out(){
if(!this.flag){
try{ this.wait();}catch(Exception e){}
}
System.out.println(this.name+" "+this.sex);
this.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();
}
}
}
public class Demo{
public static void main(String args[]){
Res r = new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
}
}
三、线程间通信-生产者消费
class Demo{
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 t3 = new Thread(pro);
Thread t2 = 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;
public synchronized void set(String name){
while(flag){
try{
this.wait();
}catch(Exception e){
}
}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
flag = true;
this.notifyAll();
}
public synchronized void out(){
while(!flag){
try{
this.wait();
}catch(Exception e){
}
}
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升级版
1、jdk1.5中,提供了,许多县城升级解决方案,将同步 synchrozed 替换成 显示 Lock 操作
将 object 中的 wait ,notify,notifyAll,替换成了condition 对象。
该对象可以 Lock锁,进行获取
2、该实例中,实现了,本方置换型对方的操作。
import java.util.concurrent.locks.*;
class Demo{
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 t3 = new Thread(pro);
Thread t2 = 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();
}
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){
}
}
}
}
五、停止线程
stop方法已经过时。
如何停止线程?
只有一种,润方法结束
开启多线程运行,运行代码通常是循环结构。
只要控制循环,就可以让run方法结束,也就是线程结束
当线程处于冻结状态,就不会读取到标记,那么线程就不会结束
当没有指定的方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除。
强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束
Thread类提供该方法, interrupt();
class Demo{
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);
}
}
}
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;
}
}
六、守护线程
对象.setDemo(true) 如果主线程结束,则这个线程自动结束
七、Join方法
抢夺主线程行权,注意,只抢夺主线程
临时加入线程
当a线程执行到了b线程的 .join() 方法时,a就会等待,等b线程都执行完,a才会执行
class Demo{
public static void main(String args[]) throws Exception{
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t1.join();
t2.start();
t2.join();
for(int x=0;x<70;x++){
System.out.println(Thread.currentThread().getName()+" "+x);
}
System.out.println("over");
}
}
class StopThread implements Runnable{
public void run(){
for(int x=0;x<70;x++){
System.out.println(Thread.currentThread().getName()+" "+x);
}
}
}
八、Byield方法 礼让
setPriority 设置优先级