Java中的线程安全问题及解决方案

Java
Java
发布日期:   2021-01-06
更新日期:   2022-07-31
文章字数:   2k
阅读时长:   8 分
阅读次数:  

  

引言：

  • 多个线程执行的不确定性可能会引起执行结果的不稳定。多个线程对共享数据的操作可能会破坏数据的完整性。
  • 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

  三个窗口同时卖票，以下实现可能存在线程的安全问题

class Window1 implements Runnable {
    private int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                ticket--;
            } else {
            	break;
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);//共享同一个Window
        Thread t2 = new Thread(w);//共享同一个Window
        Thread t3 = new Thread(w);//共享同一个Window

        t1.setName("窗口一");
        t2.setName("窗口二");
        t3.setName("窗口三");

        t1.start();
        t2.start();
        t3.start();
    }
}

  卖票过程中，出现了重票、错票（出现了线程的安全问题）。原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。解决办法：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

一、java中通过同步机制，来解决线程的安全问题

  Java对于多线程的安全问题提供了专业的解决方式，同步机制。具体分为以下两种方式：

1、同步代码块

>synchronized(同步监视器){
//需要被同步的代码
>}
  1. 操作共享数据的代码，即为需要被同步的代码。不能包含代码多了，也不能包含代码少了。
  2. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。多线程使用同一个对象的属性，多线程使用同类不同对象的静态属性，都属于共享数据。
  3. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。但是要求操作同一个共享数据的多个线程必须要共用同一把锁。
  4. 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。（自己慢慢体会吧）
  5. 补充：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，可考虑使用当前类充当同步监视器。

2、同步方法

  如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。在方法的返回值类型前添加synchronized关键字。

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this
  3. 静态的同步方法，同步监视器是：当前类本身

二、同步机制中的锁

  1. 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
  2. 同步方法的锁：静态方法（类名.class）、非静态方法（this）
  3. 同步代码块的锁：自己指定，很多时候也是指定为this或类名.class
  4. 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全
  5. 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）

三、释放锁的操作

  1. 当前线程的同步方法、同步代码块执行结束。
  2. 当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
  3. 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。

四、不会释放锁的操作

  1. 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，但不会释放同步锁。
  2. 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。应尽量避免使用suspend()和resume()来控制线程

五、同步机制的优缺点

  1. 优点

    同步的方式，解决了线程的安全问题。

  2. 缺点

    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

六、线程安全的多窗口卖票

  1. 使用“同步代码块”的方式解决“实现Runnable接口”的线程安全问题。同步代码块需要自己显式地指定同步监视器。
class Window1 implements Runnable {
    private int ticket = 100;
    Object obj = new Object();//可以用来充当同步监视器，即，锁。

    @Override
    public void run() {
        while (true) {
            synchronized (this) {//此时的this是唯一的Window1的对象   //方式二：synchronized (obj) {
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + "：买票,票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. 使用“同步代码块”的方式解决“继承Thread类”的线程安全问题。同步代码块需要自己显式地指定同步监视器。
class Window2 extends Thread {
    private static int ticket = 100;
    private static Object obj = new Object();

    @Override
    public void run() {
        while (true) {
            synchronized(Window2.class){//注意：java中类其实也是对象 Class cls = Window2.class;
            //synchronized(obj){//使用静态变量充当同步锁也是可以的
            //synchronized (this){//错误的方式：因为this代表着t1,t2,t3三个对象
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(getName() + "：买票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }

        }
    }
}

public class WindowTest2 {
    public static void main(String[] agrs) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. 使用“同步方法”的方式解决“实现Runnable接口”的线程安全问题。同步方法不需要自己显式地指定同步监视器。
class Window3 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        boolean flag = true;
        while (flag) {
            int res = show();
            if (res <= 0) {
                flag = false;
            }
        }
    }

    private synchronized int show(){//同步监视器：this
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
        return ticket;
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
  1. 使用“同步方法”的方式解决“继承Thread类”的线程安全问题。同步方法不需要自己显式地指定同步监视器。
class Window4 extends Thread {
    private static int ticket = 100;

    @Override
    public void run() {
        boolean flag = true;
        while (flag) {
            int res = show();
            if (res <= 0) {
                flag = false;
            }
        }
    }

    private static synchronized int show(){//静态方法同步监视器：Window4.class
    //synchronized int show(){//非静态方法同步监视器：this，表示t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
        return ticket;
    }
}

public class WindowTest4 {
    public static void main(String[] agrs) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}
文章作者: YangChongZhi
文章链接: http://yczlab.top/posts/fa2df08c.html
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 YangChongZhi !
Java
赏
评论
 上一篇
Java中实现线程安全的单例模式 Java中实现线程安全的单例模式
   引言： 使用java中的同步机制可以将单例模式中的“懒汉式”改写为线程安全的。而“饿汉式”单例模型本身就是线程安全的。 本身就是线程安全的“饿汉式”单例模式class Bank { //1.私有化类的构造器
2021-01-06 Java
Java
下一篇 
Java中线程的生命周期 Java中线程的生命周期
   引言： 想要实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的声明周期中通常要经历不同的几种状态。 线程的不同状态 新建 当一个Thread类或其子类的对象被声明并
2021-01-06 Java
Java
  目录