19:异常与多线程---线程同步机制

最新推荐文章于 2022-04-10 12:18:01 发布

是翼不是一

最新推荐文章于 2022-04-10 12:18:01 发布

阅读量218

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/Hhytyq/article/details/104426811

版权

java基础专栏收录该内容

43 篇文章 0 订阅

订阅专栏

一:线程安全

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
案例：
电影院要麦票，我们模拟电影院的卖票过程。假设我们要播放的电影是“葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。
我们来模拟电影院的销票窗口，实现多个窗口同时卖"葫芦娃大战奥特曼"这场电影(多个窗口一起卖100张票)需要窗口，采用线程对象来模拟；需要票，Runnabel接口类哎模拟

在这里插入图片描述

二:线程安全问题的产生及原理

RunnableImpl类

package Demo01;
/*
    实现麦票案例
*/
public class RunnableImpl  implements Runnable {
    //定义一个多个线程共享的票源
    private int ticket =100;
    //设置线程任务:麦票
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行。
       while (true){
           //判断票是否存在
           if(ticket>0){
               //提高安全问题出现的概念，让程序睡眠。
               try {
                   Thread.sleep(10);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               //票存在，麦票ticket--
               System.out.println(Thread.currentThread().getName()+"-->正在麦票"+ticket+"张票");
               ticket--;
           }
       }
    }
}

Demo01Ticket类

package Demo01;
/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出销
*/
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象。
        RunnableImpl run =new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象。
        Thread t0 =new Thread(run);
        Thread t1 =new Thread(run);
        Thread t2 =new Thread(run);
        //调用start方法开启多线程。
        t0.start();
        t1.start();
        t2.start();
    }
}

在这里插入图片描述

三:线程同步

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问同一资源的安全性问题；也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。
根据案例简述:

窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行，也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

为了保证每个线程都能正常执行原子操作JAVA引入线程同步机制。
有三种方式完成同步操作:

1:同步代码块
2:同步方法
3:锁机制

四：同步代码块:

synchronized关键字可以用于方法中的某个区块中，表示只能对这个区块中的资源实行互斥访问。
格式:

synchronized(同步锁){
	需要同步操作的代码
}

package Demo01;
/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票
    解决线程安全问题的一种方式：使用同步代码块:
    格式:
        synchronized(锁对象){
            肯会出现线程安全问题的代码(访问了共享数据的代码)
         }
    注意:
        1:通过代码块中的对象，可以使用任意的对象。
        2:但是必须保证多个线程使用的锁对象是同一个
        3:锁对象作用:
            把同步代码块锁住，只让一个线程在同步代码块中执行。
*/
public class RunnableImpl  implements Runnable {
    //定义一个多个线程共享的票源
    private int ticket =100;
    //设置线程任务:麦票
    
    //创建一个锁对象。
    Object obj =new Object();
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行。
       while (true){
           synchronized (obj){
               //判断票是否存在
               if(ticket>0){
                   //提高安全问题出现的概念，让程序睡眠。
                   try {
                       Thread.sleep(10);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   //票存在，麦票ticket--
                   System.out.println(Thread.currentThread().getName()+"-->正在麦票"+ticket+"张票");
                   ticket--;
               }
           }
       }
    }
}

Demo01Ticket类

package Demo01;
/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出销
*/
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象。
        RunnableImpl run =new RunnableImpl();
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象。
        Thread t0 =new Thread(run);
        Thread t1 =new Thread(run);
        Thread t2 =new Thread(run);
        //调用start方法开启多线程。
        t0.start();
        t1.start();
        t2.start();
    }
}

五：同步技术的原理

在这里插入图片描述

六;同步方法

同步方法:使用synchronized修饰的方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着。
格式:

public synchronized void method(){
	可能会产生线程安全问题的代码
}

注意：
同步锁是谁？
对于非static方法，同步锁就是this。
对于static方法，我们使用当前方法所在类的字节码对象(类名.class)
RunnableImpl类

package Demo01;
/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票
    解决线程安全问题的一种方式：使用同步方法
    使用步骤:
        1:把访问了共享数据的代码抽取出来，放在一个方法中。
        2:在方法上添加synchronized修饰符
    格式:定义方法的格式
    修饰符 synchronized  返回值类型  方法名(参数列表){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
     }

*/
public class RunnableImpl  implements Runnable {
    //定义一个多个线程共享的票源
    private int ticket =100;
    //设置线程任务:麦票

    //创建一个锁对象。
    Object obj =new Object();
    @Override
    public void run() {
        System.out.println("this"+this);
        //使用死循环，让卖票操作重复执行。
        while (true) {
            payTicket();
        }
    }
       /*
            定义一个同步方法
            同步方法也会把方法内部的代码锁住
            只让一个线程执行
            同步方法的锁对象是谁？
            就是实现类对象 new RunnableImpl()
            也就是this
       */
       public synchronized void payTicket(){
            //判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概念，让程序睡眠。
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，麦票ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在麦票"+ticket+"张票");
                ticket--;
            }
        }
 }

Demo01Ticket类

package Demo01;
/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出销
*/
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象。
        RunnableImpl run =new RunnableImpl();
        System.out.println("run"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象。
        Thread t0 =new Thread(run);
        Thread t1 =new Thread(run);
        Thread t2 =new Thread(run);
        //调用start方法开启多线程。
        t0.start();
        t1.start();
        t2.start();
    }
}

七:静态同步方法

RunnableImpl类

package Demo01;
/*
    买票案例出现了线程安全问题
    卖出了不存在的票和重复的票
    解决线程安全问题的一种方式：使用同步方法
    使用步骤:
        1:把访问了共享数据的代码抽取出来，放在一个方法中。
        2:在方法上添加synchronized修饰符
    格式:定义方法的格式
    修饰符 synchronized  返回值类型  方法名(参数列表){
        可能会出现线程安全问题的代码(访问了共享数据的代码)
     }

*/
public class RunnableImpl  implements Runnable {
    //定义一个多个线程共享的票源
    private static int ticket =100;
    //设置线程任务:麦票

    //创建一个锁对象。
    Object obj =new Object();
    @Override
    public void run() {
        System.out.println("this"+this);
        //使用死循环，让卖票操作重复执行。
        while (true) {
            payTicket();
        }
    }
       /*
            静态的同步方法
            把对象是谁?
            不能是this
            this是创建对象之后产生的，静态方法优于对象
            静态方法的锁对象是本类的class属性--》class文件对象。（反射).
       */
       public static synchronized void payTicket(){
            //判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概念，让程序睡眠。
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，麦票ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在麦票"+ticket+"张票");
                ticket--;
            }
        }
 }

Demo01Ticket类

package Demo01;
/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出销
*/
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象。
        RunnableImpl run =new RunnableImpl();
        System.out.println("run"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象。
        Thread t0 =new Thread(run);
        Thread t1 =new Thread(run);
        Thread t2 =new Thread(run);
        //调用start方法开启多线程。
        t0.start();
        t1.start();
        t2.start();
    }
}

八:Lock锁

java.util.concurrent.locks.lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作。
同步代码块/同方法具有的功能Lock都有，除此之外更强大，更体现面向对象。
Lock锁也称为同步锁，加锁和释放锁方法化了，如下:

public void lock();加同步锁
public void unlock():释放同步锁

RunnableImp类

package Demo01;

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

/*
   卖票案例出现了线程安全问题
   卖出了不存在和重复的票。
   
   解决线程安全问题的三种方案：使用Lock锁
   java.util.concurrent.locks.Lock接口
   Lock实现提供了比使用synchronized方法和语句可获得的更加广泛的锁定操作。
   Lock接口中的方法:
    void lock(0获取锁。
    void unlock()，释放锁。
    
    java.util.concurrent.locks.ReentrantLock implements Lock接口。
    
    s使用步骤:
        1:在成员位置创建一个ReentrantLock对象
        2:在可能会出现安全问题的代码前调用Lock接口中Lock获取池。
        3:在可能会出现安全问题的代码前调用unLock接口中的方法Lock释放池。

*/
public class RunnableImpl  implements Runnable {
    //定义一个多个线程共享的票源
    private static int ticket =100;
    //设置线程任务:麦票

    //1:在成员位置创建一个ReentrantLock对象
    Lock l=new ReentrantLock();
   
    @Override
    public void run() {
        //使用死循环，让卖票操作重复执行。
        while (true){
            //2:在可能会出现安全问题的代码前调用Lock接口中Lock获取池。
           l.lock();
            //判断票是否存在
            if (ticket<0){
                //提高安全问题出现的概念，让程序睡眠。
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    //3:在可能会出现安全问题的代码前调用unLock接口中的方法Lock释放池。
                    l.unlock();
                }
            }
        }
        /*while (true) {
            //2:在可能会出现安全问题的代码前调用Lock接口中Lock获取池。
            l.lock();
            //判断票是否存在
            if(ticket>0){
                //提高安全问题出现的概念，让程序睡眠。
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，麦票ticket--
                System.out.println(Thread.currentThread().getName()+"-->正在麦票"+ticket+"张票");
                ticket--;
            }
            //3:在可能会出现安全问题的代码前调用unLock接口中的方法Lock释放池。
            l.unlock();
        }*/
    }
 }

Demo01Ticket类

package Demo01;
/*
    模拟卖票案例
    创建3个线程，同时开启，对共享的票进行出销
*/
public class Demo01Ticket {
    public static void main(String[] args) {
        //创建Runnable接口的实现类对象。
        RunnableImpl run =new RunnableImpl();
        System.out.println("run"+run);
        //创建Thread类对象，构造方法中传递Runnable接口的实现类对象。
        Thread t0 =new Thread(run);
        Thread t1 =new Thread(run);
        Thread t2 =new Thread(run);
        //调用start方法开启多线程。
        t0.start();
        t1.start();
        t2.start();
    }
}

是翼不是一

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
19:异常与多线程---线程同步机制

一:线程安全如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。案例：电影院要麦票，我们模拟电影院的卖票过程。假设我们要播放的电影是“葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。我们来模拟电影院的销票窗口，实现多个窗口同时卖"葫芦娃大战奥特曼"这场电影(多...
复制链接

扫一扫