多线程安全问题~

强风拂过
331 阅读3分钟

「这是我参与11月更文挑战的第3天，活动详情查看：2021最后一次更文挑战」

多线程安全问题是什么？

  • 在单线程中不会出现线程安全问题，而在多线程中，因为每个线程的执行过程是不可控的，所以当出现多个线程同时访问同一个资源时，可能会导致最终的运行结果与预期的结果不一致，或者导致程序出错。 举个栗子~

假如一对异地夫妻同时去银行取钱，当丈夫和妻子同时看见卡内相同余额1000时，丈夫此时在机器上进行取款100元的操作，同时另一边妻子也进行取100元的操作。此时此刻丈夫和妻子的取100元操作都是在余额为1000元的前提下进行的，所以当操作结束时妻子和丈夫的卡内余额都应该显示的是900元。卡内有1000，现在是900，而他们一共却取出了200元，这个问题就是需要解决的线程安全。

解决线程安全问题：就是指在同一进程下开启了多个线程，如何保证多个线程之间对内存资源的操作不会同时更改一个共享数据。

如何解决线程安全问题？

在java中，我们通过同步机制，来解决线程的安全问题

方式一：同步代码

synchronized(同步监视器){需要同步的代码}

  • 说明：
    • 操作共享数据的代码，即为需要被同步的代码，—>不能包含代码多了，也不能包含代码少了
    • 共享数据：多个线程共同操作的变量。
    • 同步监视器（俗称：锁）。任何一个类的对象，都可以充当锁。
  • 要求：多个线程必须要共用同一把锁。
  • 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器

示例：

public class ThreadA extends Thread{

    private static Integer n=10;
    @Override
    public void run() {
        synchronized (ThreadA.class){
            n--;
            System.out.println(Thread.currentThread().getName()+"线程执行的结果是:"+n);
        }
    }
}

public class ThreadTest{
    public static void main(String[] args) {
        ThreadA thread1 = new ThreadA();
        ThreadA thread2 = new ThreadA();
        ThreadA thread3 = new ThreadA();

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

运行结果：

Thread-0线程执行的结果是:9
Thread-2线程执行的结果是:8
Thread-1线程执行的结果是:7

说明：在继承Thread类创建多线程方式中，慎用this充当同步监视器，可以考虑使用当前类来做同步监视器。

方式二：同步方法

示例：

public class ThreadA extends Thread{

    private static Integer n=10;
    private static ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        math();
    }

    public synchronized void math(){
        n--;
        System.out.println(Thread.currentThread().getName()+"线程执行的结果是:"+n);
    }
}

方式三：Lock锁

示例：

public class ThreadA extends Thread{

    private static Integer n=10;
    private static ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        n--;
        System.out.println(Thread.currentThread().getName()+"线程执行的结果是:"+n);
        lock.unlock();
    }
}

总结：

1、同步方法仍然涉及到同步监视器，只是不需要我们显示的声明。

2、非静态的同步方法，同步监视器是：this。

3、静态的同步方法，同步监视器是：当前类本身。

线程死锁（线程同步的致命问题）

  • 死锁的理解：不同线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程死锁。
  • 说明：
    • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续执行。
    • 我们使用同步时，要避免死锁。 演示示例：
public class ThreadTest {

    public static void main(String[] args) {

        StringBuffer s1=new StringBuffer();
        StringBuffer s2=new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized (s1) {

                    s1.append("a");
                    s2.append("1");

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

                    synchronized (s2){
                        s1.append("b");
                        s2.append("2");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (s2) {

                    s1.append("c");
                    s2.append("3");

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

                    synchronized (s1){
                        s1.append("d");
                        s2.append("4");

                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();

    }
}
avatar
文章
阅读
粉丝