Java基础12：线程；等待唤醒机制；锁；线程优先级；

最新推荐文章于 2023-07-08 13:19:00 发布

若云_bai

最新推荐文章于 2023-07-08 13:19:00 发布

阅读量578

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/zxloveooo/article/details/10476923

版权

java基础专栏收录该内容

39 篇文章 0 订阅

订阅专栏

关键字：线程；等待唤醒机制；锁；线程优先级；

一、线程间的通信

其实就是多个线程在操作同一个资源，就是操作的动作不同。

二、等待唤醒机制
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 设置优先级

若云_bai

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础12：线程；等待唤醒机制；锁；线程优先级；

一、线程间的通信其实就是多个线程在操作同一个资源，就是操作的动作不同。二、等待唤醒机制 1、wait(),notify(),notifyAll(),都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。 2、为什么这些操作线程的方法要定义Object类中呢？因为这些方法在操作同步中，线程，都必须要表示它们所操作线程只有的锁，只有同
复制链接

扫一扫