JAVA之线程安全以及同步

于 2019-11-12 21:03:20 发布
阅读量119 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43153854/article/details/103033201
版权

一.线程安全

1. 线程安全问题

在这里插入图片描述

2. 线程安全问题的代码实现

需求：
模拟卖票案例
创建3个线程，同时开启，对共享的票进行出售
实现类

/*
    实现卖票案例
 */
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--;
            }
        }
    }
}

主程序

/*
    模拟卖票案例
    创建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();
    }
}

结果：

Thread-1-->正在卖第5张票
Thread-2-->正在卖第4张票
Thread-0-->正在卖第4张票
Thread-1-->正在卖第2张票
Thread-0-->正在卖第1张票
Thread-2-->正在卖第1张票
Thread-1-->正在卖第-1张票

3. 线程安全问题产生的原理

在这里插入图片描述

二.线程同步

1. 解决线程安全的第一种方式：同步代码块

卖票案例出现了线程安全问题
卖出了不存在的票和重复的票

解决线程安全问题的一种方案：使用同步代码块
格式：
synchronized(锁对象){
可能会出现线程安全问题的代码（访问了共享数据的代码）
}
注意：
1.通过代码块中的锁对象，可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是同一个
3.锁对象作用：
把同步代码块锁住，只让一个线程在同步代码块中执行

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的一种方案：使用同步代码块
    格式：
        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--;
                }
            }
        }
    }
}

2. 同步代码块的原理

在这里插入图片描述

3. 解决线程安全的第二种方式：同步方法

解决线程安全问题的一种方案：使用同步方法
使用步骤：
1.把访问了共享数据的代码抽取出来，放到一个方法中
2.在方法上添加synchronized修饰符

格式：定义方法的格式
修饰符 synchronized 返回值类型 方法名（参数列表）{
可能出现线程安全问题的代码（访问了共享数据的代码）
}

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的一种方案：使用同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放到一个方法中
        2.在方法上添加synchronized修饰符

    格式：定义方法的格式
    修饰符 synchronized 返回值类型 方法名（参数列表）{
        可能出现线程安全问题的代码（访问了共享数据的代码）
    }
 */
public class RunnableImpl implements Runnable {
    //定义一个多个线程共享的票源
    private int ticket = 100;

    //设置线程任务：卖票
    @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--;
        }
    }
}

4. 静态的同步方法

静态的同步方法
锁对象不能是this
this是创建对象之后产生的，静态方法优先于对象
静态方法的锁对象是本类的class属性—>class文件对象（反射）

package Synchronized03;

/*
    卖票案例出现了线程安全问题
    卖出了不存在的票和重复的票

    解决线程安全问题的一种方案：使用同步方法
    使用步骤：
        1.把访问了共享数据的代码抽取出来，放到一个方法中
        2.在方法上添加synchronized修饰符

    格式：定义方法的格式
    修饰符 synchronized 返回值类型 方法名（参数列表）{
        可能出现线程安全问题的代码（访问了共享数据的代码）
    }
 */
public class RunnableImpl implements Runnable {
    //定义一个多个线程共享的票源
    private static int ticket = 100;

    //设置线程任务：卖票
    @Override
    public void run() {
        System.out.println("this:" + this);
        //使用死循环，让卖票重复执行
        while (true) {
            //先判断票是否存在
            payTicket();
        }
    }

    /*
        静态的同步方法
        锁对象不能是this
        this是创建对象之后产生的，静态方法优先于对象
        静态方法的锁对象是本类的class属性--->class文件对象（反射）
     */
    public static /*synchronized */void payTicket() {
        synchronized (RunnableImpl.class) {
            //先判断票是否存在
            if (ticket > 0) {
                //提高安全问题出现的概论，让程序睡眠
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //票存在，卖票，ticket--
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket--;
            }
        }
    }
}

5. 解决线程安全问题的第三种方式：Lock锁

解决线程安全问题的第三种解决方案：使用Lock锁
java.util.concurrent.locks 接口
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
Lock接口中的方法：
void lock()获取锁。
void unlock() 释放锁。
java.util.concurrent.locks.ReentrantLock implements Lock接口

使用步骤：
1.在成员位置创建一个实现类对象ReentrantLock对象
2.在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁

package Lock;

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

/*
    实现卖票案例

    解决线程安全问题的第三种解决方案：使用Lock锁
    java.util.concurrent.locks 接口
    Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
    Lock接口中的方法：
        void lock()获取锁。
        void unlock() 释放锁。
        java.util.concurrent.locks.ReentrantLock implements Lock接口

    使用步骤：
        1.在成员位置创建一个实现类对象ReentrantLock对象
        2.在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
        3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁

 */
public class RunnableImpl implements Runnable {
    //定义一个多个线程共享的票源
    private 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();
                }
                //票存在，卖票，ticket--
                System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                ticket--;
            }
            //3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁
            l.unlock();
        }
    }
}

使用finally释放优化代码
无论程序是否异常，都会把锁释放掉

package Lock;

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

/*
    实现卖票案例

    解决线程安全问题的第三种解决方案：使用Lock锁
    java.util.concurrent.locks 接口
    Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。
    Lock接口中的方法：
        void lock()获取锁。
        void unlock() 释放锁。
        java.util.concurrent.locks.ReentrantLock implements Lock接口

    使用步骤：
        1.在成员位置创建一个实现类对象ReentrantLock对象
        2.在可能出现安全问题的代码前调用Lock接口中的方法lock获取锁
        3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁

 */
public class RunnableImpl implements Runnable {
    //定义一个多个线程共享的票源
    private 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);
                    //票存在，卖票，ticket--
                    System.out.println(Thread.currentThread().getName() + "-->正在卖第" + ticket + "张票");
                    ticket--;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //3.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁
                    l.unlock();//无论程序是否异常，都会把锁释放掉
                }

            }
        }
    }


/*    //设置线程任务：卖票
    @Override
    public void run() {
        //使用死循环，让卖票重复执行
        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.在可能出现安全问题的代码后调用Lock接口中的方法unlock释放锁
            l.unlock();
        }
    }*/
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值