java多线程编程问题以及解决办法

java多线程编程问题以及解决办法

    多线程编程虽然可以提高程序的性能和响应速度，但也带来了许多复杂的问题，如竞态条件、死锁、线程安全问题、内存一致性错误等。常用的解决方法包括使用同步机制（如 synchronized 和 ReentrantLock）、线程池、volatile 关键字、以及合适的线程间通信机制（如 wait/notify 和 Condition）。

   下面多线程编程中常见的一些问题以及对应的解决办法

   一、竞态条件（Race Conditions）

   竞态条件是指多个线程同时访问和修改共享数据时，由于操作顺序的不确定性，可能导致数据的不一致或程序行为异常。竞态条件是多线程编程中最常见的问题之一。

   1. 示例

public class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 预期值是2000，但是可能输出不正确的结果
        System.out.println(counter.getCount());
    }
}

   说明：上面的运行结果是不稳定的

   2. 解决办法

   使用同步机制，如 synchronized 关键字或显式锁（ReentrantLock）来确保对共享数据的访问是互斥的。

   1） synchronized

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

   2）ReentrantLock  

public class ReentrantLockCounter {
    public static ReentrantLock lock = new ReentrantLock();
    public static int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
    /**
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        ReentrantLockCounter counter = new ReentrantLockCounter();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                lock.lock();
                try {
                    System.out.println(Thread.currentThread().getName()  + " " + i);
                    counter.increment();
                } finally {
                    lock.unlock();
                }
            }
        };
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println(counter.getCount());
    }
}

   二、死锁（Deadlock）

   死锁是指两个或多个线程相互等待对方释放锁，从而导致线程永久阻塞。死锁通常发生在多个锁的情况下，当线程获取锁的顺序不一致时容易产生死锁。

   1. 示例

public class DeadlockDemo {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                synchronized (lock2) {
                    System.out.println("Thread 1: Holding lock 1 & 2...");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");
                try { Thread.sleep(10); } catch (InterruptedException e) {}
                synchronized (lock1) {
                    System.out.println("Thread 2: Holding lock 2 & 1...");
                }
            }
        });

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

    2. 解决办法

    避免嵌套锁定，尽量减少锁的数量，或通过使用 tryLock 方法来避免死锁。

public class AvoidDeadlockDemo {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock() && lock2.tryLock()) {
                    System.out.println("Thread 1: Acquired locks...");
                }
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock() && lock1.tryLock()) {
                    System.out.println("Thread 2: Acquired locks...");
                }
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

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

   三、线程安全问题

   多线程访问共享数据时，如果没有适当的同步机制，可能导致数据的不一致性和程序行为的不可预知性。这类问题统称为线程安全问题。

   使用同步机制确保线程安全，如 synchronized 关键字、显式锁（ReentrantLock）或使用线程安全的类（如 AtomicInteger）。

   还是以竞态条件中的累加计算例子来说明：

public class SafeCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

   三、 上下文切换开销

   线程切换（Context Switching）是指CPU从一个线程切换到另一个线程的过程。频繁的线程切换会导致CPU时间片的浪费，降低程序性能。上下文切换的开销包括保存和恢复线程状态，以及处理操作系统调度器。

   示例：大量创建和销毁线程，或者频繁的线程切换，都会增加上下文切换的开销。

   代码如下：

public class ContextSwitchDemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                System.out.println("Thread " + Thread.currentThread().getId());
            }).start();
        }
    }
}

    说明：上面的代码会创建10000个线程

    解决方法： 使用线程池来重用线程，减少创建和销毁线程的开销。

    代码如下：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10000; i++) {
            executor.submit(() -> {
                System.out.println("Thread " + Thread.currentThread().getId());
            });
        }
        executor.shutdown();
    }
}

    说明：这里面只会创建10线程来循环执行任务

    五、内存一致性错误

    内存一致性错误（Memory Consistency Errors）是指由于缺乏适当的同步机制，不同线程对共享变量的修改在内存中的可见性不一致，导致线程读取到过期或不正确的数据。

    1. 示例

public class MemoryConsistencyDemo {
    private static boolean ready = false;
    private static int number;

    private static class ReaderThread extends Thread {
        public void run() {
            while (!ready) {
                Thread.yield();
            }
            System.out.println(number);
        }
    }

    public static void main(String[] args) {
        new ReaderThread().start();
        number = 42;
        ready = true;
    }
}

   2. 解决办法

   使用 volatile 关键字或同步机制来确保变量的可见性。

   将ready属性设置为：private static  volatile boolean ready = false;

 

    参考链接：

    https://www.aolifu.org/article/thread_question