Java——线程安全（synchronized解决线程安全问题，窗口售票为例）

热爱编程的申同学

已于 2022-08-01 19:59:07 修改

阅读量998

点赞数

分类专栏： JavaSE 文章标签： java

于 2022-08-01 14:27:49 首次发布

本文链接：https://blog.csdn.net/select_myname/article/details/126097552

版权

JavaSE 专栏收录该内容

35 篇文章 6 订阅

订阅专栏

1、什么是线程安全？

多线程执行的结果和单线程运行的结果是一样的，就是线程安全的。

2、卖票线程出现的问题

Runnable实现类

public class MyRunnableDemo implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
                //判断票数是否大于0 
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    ticket--;
                    try {
                        //每次输出让线程休眠一下
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    //如果票数为0，则直接退出方法  线程结束
                    System.out.println(Thread.currentThread().getName()+"线程结束");
                    break;
                }
          
        }

    }
}

测试类

public class Test {
    public static void main(String[] args) {
        MyRunnableDemo r=new MyRunnableDemo();
        Thread t1=new Thread(r,"窗口1");
        Thread t2=new Thread(r,"窗口2");
        Thread t3=new Thread(r,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

售票线程问题：线程出现多个线程同时卖出一个票，而且有时会出现0票和负数票这种不存在的票，这就是线程安全不安全问题，所以我们需要去解决这种问题。

线程安全问题满足三个条件：

1、是否有共享资源？是
2、是否有多条执行路径？是
3、是否这多条执行路径操作共享资源？是

如果满足上面三个条件，则就认定线程存在线程问题。

3、解决线程不安全问题——线程同步(实现Runnable接口方式)

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

实现同步的方式：同步代码块、同步方法、Lock锁

3.1、同步代码块

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

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

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁，在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着 (BLOCKED)。

在Runnable实现类中加入同步代码块

public class MyRunnableDemo implements Runnable {
    private int ticket = 100;
    //创建同步锁对象，这个对象是可以任意类型
    private Object o = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (o) {
                //判断票数是否为0
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");    
                    ticket--;
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    //如果票数为0，则线程结束 结束循环
                    System.out.println(Thread.currentThread().getName() + "线程结束");
                    break;
                }

            }
        }
    }
}

public class Test {
    public static void main(String[] args) {
        MyRunnableDemo r=new MyRunnableDemo();
        Thread t1=new Thread(r,"窗口1");
        Thread t2=new Thread(r,"窗口2");
        Thread t3=new Thread(r,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

3.2、同步方法

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

public class MyRunnableDemo implements Runnable {
    private static int ticket = 100;


    @Override
    public void run() {
        // payTicket();非静态同步方法
        payTicketStatic();//静态同步方法
    }

    //非静态同步方法
    public void payTicket() {
        //同步锁对象是当前对象
        synchronized (this) {
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    ticket--;
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + "线程结束");
                    break;
                }
            }
        }
    }
    //静态同步方法
    public static void payTicketStatic(){
        //同步锁对象是本类，静态方法的锁对象是本类的class属性-->class文件对象(反射)
        synchronized (MyRunnableDemo.class) {
            while (true) {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    ticket--;
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + "线程结束");
                    break;
                }
            }
        }
    }
}

同步方法中的锁是谁？

1、对于非static方法,同步锁就是this。

2、对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。

3、synchronized关键字加到static静态方法上是给Class类上锁，而synchronized关键字加到非static静态方法上是给对象上锁（一个是对象锁，另外一个是Class锁）

3.3、Lock锁

java.util.concurrent.locks.Lock机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作, 同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。

Lock接口常用方法

方法名	说明
public void lock()	加同步锁
public void unlock()	释放同步锁

操作步骤：

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

public class MyRunnableDemo implements Runnable {
    //定义一个多个线程共享的资源
    private static int ticket = 100;
    //在成员位置创建一个ReentranLock对象
    Lock l=new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            l.lock();//启动锁
            if (ticket > 0) {
                try {
                    Thread.sleep(10);//线程睡眠
                    System.out.println(Thread.currentThread().getName() + "正在卖第" + ticket + "张票");
                    ticket--;
                }catch (InterruptedException e){
                    e.printStackTrace();
                }finally {
                    //释放锁
                    l.unlock();
                }
            } else {
                System.out.println(Thread.currentThread().getName() + "线程结束");
                break;
            }
        }

    }
}

4、解决线程不安全问题——线程同步(继承Thread类方式)

4.1、同步代码块

public class MyThreadDemo extends Thread {
    //把当前的票源修改为static
    private static int ticket = 100;

    @Override
    public void run() {
            while (true) {
                //同步代码块的锁对象是其本身.class
                synchronized (MyThreadDemo.class) {
                    if (ticket > 0) {
                        System.out.println(getName() + "卖出一张票，还剩" + (--ticket)+"张票");     
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }else{
                        break;
                    }
                }
            }
    }
}

public class Test{
    public static void main(String[] args) {
        MyThreadDemo m1=new MyThreadDemo();
        MyThreadDemo m2=new MyThreadDemo();
        MyThreadDemo m3=new MyThreadDemo();
        m1.setName("窗口1");
        m2.setName("窗口2");
        m3.setName("窗口3");
        m1.start();
        m2.start();
        m3.start();

    }
}

4.2、同步方法

public class MyThreadDemo extends Thread {
    //把当前的票源修改为static
    private static int ticket = 100;
    boolean flag=true;//定义一个boolean类型变量用来控制循环
    @Override
    public void run() {
        while (flag) {
            flag=payTicketStatic();
        }
    }

    //继承thread类的同步方法，只能是静态
    public static synchronized boolean payTicketStatic() {
        //为了卖票一直操作
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出一张票，还剩" + (--ticket) + "张票");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            //如果ticket小于等于0就返回false，循环结束
            return false;
        }
        return true;
    }
    
}

public class Test{
    public static void main(String[] args) {
        MyThreadDemo m1=new MyThreadDemo();
        MyThreadDemo m2=new MyThreadDemo();
        MyThreadDemo m3=new MyThreadDemo();
        m1.setName("窗口1");
        m2.setName("窗口2");
        m3.setName("窗口3");
        m1.start();
        m2.start();
        m3.start();

    }
}

4.3、Lock锁

public class MyThreadDemo extends Thread {
    //把当前的票源修改为static
    private static int ticket = 100;
    //继承Trhead类的lock锁一定是静态的
    private static Lock l=new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            l.lock();
            if (ticket > 0) {
                try {
                    System.out.println(getName() + "卖出一张票，还剩" + (--ticket)+"张票");
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    l.unlock();
                }
            }
        }

    }
}

public class Test{
    public static void main(String[] args) {
        MyThreadDemo m1=new MyThreadDemo();
        MyThreadDemo m2=new MyThreadDemo();
        MyThreadDemo m3=new MyThreadDemo();
        m1.setName("线程1");
        m2.setName("线程2");
        m3.setName("线程3");
        m1.start();
        m2.start();
        m3.start();
    }
}