Java多线程安全问题的解决方式

  • Z时代
  • 2024-01-10
  • 分类：综合

java

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错

示例

class Window implements Runnable{
    private int ticket = 10;
    @Override
    public void run() {
        while (true){
            if (ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}
public class TicketDemo {
    public static void main(String[] args) {
        Window w = new Window();
        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();
    }
}

在这个示例中，三个窗口代表三个线程同时出售10张票，运行结果中却出现了错票，有0和-1的票号。这就是一个线程在操作共享数据的过程中，其他线程也参与了运算，导致线程安全问题的产生。

解决办法

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式：同步机制
同步锁机制就是是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，无法访问它，而在其被解锁之时，另一个任务就可以锁定并使用它。

1.同步代码块

synchronized (对象){ 
    // 需要被同步的代码；
}

 示例

class Window implements Runnable{
    private int ticket = 10;
    @Override
    public void run() {
        while (true){
            synchronized(this){
                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }
        }
    }
}
public class TicketDemo {
    public static void main(String[] args) {
        Window w = new Window();
        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();
    }
}

同步代码块中的锁可以自己指定，很多时候指定为this或类名.class。任何对象都可以作为同步锁，所有对象都自动含有单一的锁（监视器）。
例如使用实现Runnable接口的方式实现多线程，由于多个线程共用一个对象，此时同步锁可以是任意对象。若是使用继承Thread的方式实现多线程，由于多个线程间不是同一个对象，此时只能使用类名.class或者静态对象。总而言之必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全。

2. 同步方法

public synchronized void show (String name){
    …
}

 示例

class Window extends Thread{
    private static int ticket = 10;
    private static Object obj = new Object();
    @Override
    public void run() {
        while (ticket != 0){
            sell();
        }
    }
    private static synchronized void sell(){
            if (ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
                ticket--;
            }
    }
}
public class TicketDemo {
    public static void main(String[] args) {
        Window w1 = new Window();
        Window w2 = new Window();
        Window w3 = new Window();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}

  • 同步方法的锁：静态方法（类名.class）、非静态方法（this）

  • 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this）

3. Lock（锁）

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的 工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象 加锁，线程开始访问共享资源之前应先获得Lock对象。
ReentrantLock类实现了 Lock ，它拥有与synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

class A{
    private final ReentrantLock lock = new ReenTrantLock(); 
    public void m(){ 
        lock.lock(); 
        try{ 
            //保证线程安全的代码; 
        } 
        finally{ 
            lock.unlock();  
        } 
    }
}

 示例

import java.util.concurrent.locks.ReentrantLock;
class Window implements Runnable{
    private int ticket = 10;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try {
                //2.调用锁定方法lock()
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"卖票，票号："+ticket);
                    ticket--;
                }else {
                    break;
                }
            } finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        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();
    }
}


Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放。使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

原文出处：

姜贞羽1, Java多线程安全问题的解决方式, https://blog.csdn.net/weixin_43868299/article/details/109039619?utm_medium=distribute.pc_category.none-task-blog-hot-4.nonecase&depth_1-utm_source=distribute.pc_category.none-task-blog-hot-4.nonecase&request_id=

以上是 Java多线程安全问题的解决方式 的全部内容， 来源链接： utcz.com/z/393186.html

回到顶部