百木园-与人分享，
就是让自己快乐。
当前位置：百木园 > 野生技术 > 正文

多线程（生产者和消费者问题【死锁--解决线程安全--等待唤醒机制---线程状态转换图】）

2022-04-06 分类：野生技术 阅读(188) 评论(0)

Lock：--------------------------锁对象
* void lock()： 获取锁。
* void unlock():释放锁。
* ReentrantLock是Lock的实现类、

package cn.itcast_01;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SellTicket implements Runnable {

    // 定义票
    private int tickets = 100;

    // 定义锁对象
    private Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                // 加锁
                lock.lock();
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()
                            + \"正在出售第\" + (tickets--) + \"张票\");
                }
            } finally {
                // 释放锁
                lock.unlock();
            }
        }
    }

}
package cn.itcast_01;
/*
 * 虽然我们可以理解同步代码块和同步方法的锁对象问题，但是我们并没有直接看到在哪里加上了锁，在哪里释放了锁，
 * 为了更清晰的表达如何加锁和释放锁,JDK5以后提供了一个新的锁对象Lock。
 * 
 * Lock：
 *         void lock()： 获取锁。
 *         void unlock():释放锁。  
 * ReentrantLock是Lock的实现类.
 */
public class SellTicketDemo {
    public static void main(String[] args) {
        // 创建资源对象
        SellTicket st = new SellTicket();

        // 创建三个窗口
        Thread t1 = new Thread(st, \"窗口1\");
        Thread t2 = new Thread(st, \"窗口2\");
        Thread t3 = new Thread(st, \"窗口3\");

        // 启动线程
        t1.start();
        t2.start();
        t3.start();
    }
}

生产者和消费者题代码改进2并解决线程安全问题

【学生类】

package cn.itcast_04;

public class Student {
    String name;
    int age;
}

设置信息类-----实现线程接口

package cn.itcast_04;

public class SetThread implements Runnable {

    private Student s;
    private int x = 0;

    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                if (x % 2 == 0) {
                    s.name = \"林青霞\";//刚走到这里，就被别人抢到了执行权
                    s.age = 27;
                } else {
                    s.name = \"刘意\"; //刚走到这里，就被别人抢到了执行权
                    s.age = 30;
                }
                x++;
            }
        }
    }
}

获取信息类---实现线程接口

package cn.itcast_04;

public class GetThread implements Runnable {
    private Student s;

    public GetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                System.out.println(s.name + \"---\" + s.age);
            }
        }
    }
}

测试类

package cn.itcast_04;

/*
 * 分析：
 *         资源类：Student    
 *         设置学生数据:SetThread(生产者)
 *         获取学生数据：GetThread(消费者)
 *         测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
 * 如何实现呢?
 *         在外界把这个数据创建出来，通过构造方法传递给其他的类，---让其使用同一个资源对象
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够你执行很多次。
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境        是
 *         B:是否有共享数据        是
 *         C:是否有多条语句操作共享数据    是
 * 解决方案：
 *         加锁。
 *         注意：
 *             A:不同种类的线程都要加锁。
 *             B:不同种类的线程加的锁必须是同一把。
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建资源
        Student s = new Student();
        
        //设置和获取的类
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        //线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        //启动线程
        t1.start();
        t2.start();
    }
}

生产者和消费者之等待唤醒机制代码实现

学生类

package cn.itcast_05;

public class Student {
    String name;
    int age;
    boolean flag; // 默认情况是没有数据，如果是true，说明有数据
}

设置学生类---线程实现

package cn.itcast_05;

public class SetThread implements Runnable {

    private Student s;
    private int x = 0;

    public SetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                //判断有没有
                if(s.flag){
                    try {
                        s.wait(); //t1等着，释放锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                if (x % 2 == 0) {
                    s.name = \"林青霞\";
                    s.age = 27;
                } else {
                    s.name = \"刘意\";
                    s.age = 30;
                }
                x++; //x=1
                
                //修改标记
                s.flag = true;
                //唤醒线程
                s.notify(); //唤醒t2,唤醒并不表示你立马可以执行，必须还得抢CPU的执行权。
            }
            //t1有，或者t2有
        }
    }
}

获取信息--学生类----线程实现

package cn.itcast_05;

public class GetThread implements Runnable {
    private Student s;

    public GetThread(Student s) {
        this.s = s;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (s) {
                if(!s.flag){
                    try {
                        s.wait(); //t2就等待了。立即释放锁。将来醒过来的时候，是从这里醒过来的时候
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
                System.out.println(s.name + \"---\" + s.age);
                //林青霞---27
                //刘意---30
                
                //修改标记
                s.flag = false;
                //唤醒线程
                s.notify(); //唤醒t1
            }
        }
    }
}

测试类

等待唤醒：
 *         Object类中提供了三个方法：
 *             wait():等待
 *             notify():唤醒单个线程
 *             notifyAll():唤醒所有线程
package cn.itcast_05;

/*
 * 分析：
 *         资源类：Student    
 *         设置学生数据:SetThread(生产者)
 *         获取学生数据：GetThread(消费者)
 *         测试类:StudentDemo
 * 
 * 问题1：按照思路写代码，发现数据每次都是:null---0
 * 原因：我们在每个线程中都创建了新的资源,而我们要求的时候设置和获取线程的资源应该是同一个
 * 如何实现呢?
 *         在外界把这个数据创建出来，通过构造方法传递给其他的类。
 * 
 * 问题2：为了数据的效果好一些，我加入了循环和判断，给出不同的值,这个时候产生了新的问题
 *         A:同一个数据出现多次
 *         B:姓名和年龄不匹配
 * 原因：
 *         A:同一个数据出现多次
 *             CPU的一点点时间片的执行权，就足够你执行很多次。
 *         B:姓名和年龄不匹配
 *             线程运行的随机性
 * 线程安全问题：
 *         A:是否是多线程环境        是
 *         B:是否有共享数据        是
 *         C:是否有多条语句操作共享数据    是
 * 解决方案：
 *         加锁。
 *         注意：
 *             A:不同种类的线程都要加锁。
 *             B:不同种类的线程加的锁必须是同一把。
 * 
 * 问题3:虽然数据安全了，但是呢，一次一大片不好看，我就想依次的一次一个输出。
 * 如何实现呢?
 *         通过Java提供的等待唤醒机制解决。
 * 
 * 等待唤醒：
 *         Object类中提供了三个方法：
 *             wait():等待
 *             notify():唤醒单个线程
 *             notifyAll():唤醒所有线程
 *         为什么这些方法不定义在Thread类中呢?
 *             这些方法的调用必须通过锁对象调用，而我们刚才使用的锁对象是任意锁对象。
 *             所以，这些方法必须定义在Object类中。
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建资源
        Student s = new Student();
        
        //设置和获取的类
        SetThread st = new SetThread(s);
        GetThread gt = new GetThread(s);

        //线程类
        Thread t1 = new Thread(st);
        Thread t2 = new Thread(gt);

        //启动线程
        t1.start();
        t2.start();
    }
}

线程的状态转换图及执行情况

 

 

来源：https://www.cnblogs.com/ztg-java-xuexi/p/16102975.html
本站部分图文来源于网络，如有侵权请联系删除。

未经允许不得转载：百木园 » 多线程（生产者和消费者问题【死锁--解决线程安全--等待唤醒机制---线程状态转换图】）
标签：

相关推荐

  • 暂无文章

热门文章