MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java多线程编程中的最佳实践与常见误区

2023-09-061.5k 阅读

Java多线程编程中的最佳实践

1. 使用线程池管理线程

在Java多线程编程中，创建和销毁线程是相对昂贵的操作。频繁地创建和销毁线程会消耗大量系统资源，影响程序性能。线程池通过复用已有的线程来执行任务，避免了线程的频繁创建和销毁，从而提高系统性能和资源利用率。

在Java中，我们可以使用java.util.concurrent.Executors类来创建不同类型的线程池。例如，创建一个固定大小的线程池：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个固定大小为5的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            executorService.submit(() -> {
                System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
                // 模拟任务执行
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 关闭线程池
        executorService.shutdown();
    }
}

在上述代码中，Executors.newFixedThreadPool(5)创建了一个固定大小为5的线程池。这意味着线程池最多同时执行5个任务，其余任务将在队列中等待。submit方法用于提交任务到线程池执行。最后，调用shutdown方法关闭线程池，不再接受新任务，但会继续执行已提交的任务。

2. 正确使用锁机制

在多线程环境下，为了保证数据的一致性和线程安全，常常需要使用锁机制。Java提供了synchronized关键字和java.util.concurrent.locks.Lock接口来实现锁。

synchronized关键字是Java内置的同步机制，可以用于修饰方法或代码块。例如：

public class SynchronizedExample {
    private static int count = 0;

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

    public static void main(String[] args) {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increment();
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Final count: " + count);
    }
}

在上述代码中，increment方法被synchronized修饰，这意味着同一时间只有一个线程能够执行该方法，从而保证了count变量的线程安全。

java.util.concurrent.locks.Lock接口提供了更灵活和强大的锁机制，例如可中断的锁获取、公平锁等。以ReentrantLock为例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private static int count = 0;
    private static Lock lock = new ReentrantLock();

    public static void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increment();
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("Final count: " + count);
    }
}

在这个例子中，ReentrantLock通过lock方法获取锁，在try块中执行需要同步的代码，最后在finally块中通过unlock方法释放锁，确保无论代码执行过程中是否发生异常，锁都能被正确释放。

3. 避免死锁

死锁是多线程编程中常见的问题，当两个或多个线程相互等待对方释放资源时，就会发生死锁。为了避免死锁，可以遵循以下几个原则：

按顺序获取锁：如果多个线程需要获取多个锁，确保它们以相同的顺序获取锁。例如：

public class DeadlockAvoidance1 {
    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 acquired lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1 acquired lock2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 2 acquired lock1");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 2 acquired lock2");
                }
            }
        });

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

在上述代码中，thread1和thread2都以相同的顺序获取lock1和lock2，从而避免了死锁。

使用定时锁：java.util.concurrent.locks.Lock接口提供了tryLock方法，可以在指定时间内尝试获取锁。如果在指定时间内获取不到锁，则放弃获取，避免无限等待。例如：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

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

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            boolean gotLock1 = false;
            boolean gotLock2 = false;
            try {
                gotLock1 = lock1.tryLock(1, java.util.concurrent.TimeUnit.SECONDS);
                if (gotLock1) {
                    System.out.println("Thread 1 acquired lock1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    gotLock2 = lock2.tryLock(1, java.util.concurrent.TimeUnit.SECONDS);
                    if (gotLock2) {
                        System.out.println("Thread 1 acquired lock2");
                    } else {
                        System.out.println("Thread 1 could not acquire lock2");
                    }
                } else {
                    System.out.println("Thread 1 could not acquire lock1");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (gotLock2) {
                    lock2.unlock();
                }
                if (gotLock1) {
                    lock1.unlock();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            boolean gotLock1 = false;
            boolean gotLock2 = false;
            try {
                gotLock1 = lock1.tryLock(1, java.util.concurrent.TimeUnit.SECONDS);
                if (gotLock1) {
                    System.out.println("Thread 2 acquired lock1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    gotLock2 = lock2.tryLock(1, java.util.concurrent.TimeUnit.SECONDS);
                    if (gotLock2) {
                        System.out.println("Thread 2 acquired lock2");
                    } else {
                        System.out.println("Thread 2 could not acquire lock2");
                    }
                } else {
                    System.out.println("Thread 2 could not acquire lock1");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                if (gotLock2) {
                    lock2.unlock();
                }
                if (gotLock1) {
                    lock1.unlock();
                }
            }
        });

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

在这个例子中，tryLock方法尝试在1秒内获取锁，如果获取不到则打印相应信息，避免了死锁。

4. 使用线程安全的数据结构

Java提供了许多线程安全的数据结构，如ConcurrentHashMap、CopyOnWriteArrayList等。使用这些数据结构可以简化多线程编程，提高代码的可读性和可靠性。

ConcurrentHashMap是一个线程安全的哈希表，允许多个线程同时读，并且在一定程度上允许并发写。例如：

import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                map.put("key" + i, i);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 1000; i < 2000; i++) {
                map.put("key" + i, i);
            }
        });

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

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

        System.out.println("Size of map: " + map.size());
    }
}

在上述代码中，ConcurrentHashMap允许thread1和thread2同时向其中插入数据，而不需要额外的同步操作，保证了线程安全。

CopyOnWriteArrayList是一个线程安全的List，它在修改时会创建一个新的数组，读操作则在原数组上进行，从而实现读写分离，提高并发性能。例如：

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class CopyOnWriteArrayListExample {
    public static void main(String[] args) {
        List<String> list = new CopyOnWriteArrayList<>();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                list.add("element" + i);
            }
        });

        Thread thread2 = new Thread(() -> {
            for (String element : list) {
                System.out.println(element);
            }
        });

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

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

在这个例子中，thread1向CopyOnWriteArrayList中添加元素，thread2可以同时安全地遍历该列表，不会抛出ConcurrentModificationException。

5. 合理使用volatile关键字

volatile关键字用于修饰变量，保证该变量在多线程环境下的可见性。当一个变量被声明为volatile时，任何线程对它的修改都会立即被其他线程看到。

例如，实现一个简单的线程安全的标志位：

public class VolatileExample {
    private static volatile boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("Thread 1 set flag to true");
        });

        Thread thread2 = new Thread(() -> {
            while (!flag) {
                // 等待flag变为true
            }
            System.out.println("Thread 2 saw flag is true");
        });

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

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

在上述代码中，如果flag变量没有被声明为volatile，thread2可能会一直循环，因为它无法及时看到thread1对flag的修改。volatile关键字确保了thread1对flag的修改对thread2是可见的。

Java多线程编程中的常见误区

1. 对synchronized关键字的误解

误区一：认为synchronized修饰的方法执行效率低 虽然synchronized关键字会引入同步开销，但在很多情况下，这种开销是必要的，以保证数据的一致性和线程安全。在一些场景中，合理使用synchronized并不会对性能产生严重影响。例如，对于一些关键的、需要保证原子性的操作，如对共享资源的读写，使用synchronized是正确的选择。而且，从Java 6开始，JVM对synchronized进行了大量优化，如偏向锁、轻量级锁等，大大提高了其性能。

误区二：滥用synchronized 有些开发者为了保证线程安全，会在所有可能涉及多线程访问的方法上都加上synchronized关键字，这会导致不必要的性能开销。例如，对于一些只读方法，并不需要同步，因为多个线程同时读取不会产生数据不一致问题。正确的做法是只在需要保证线程安全的关键代码段上使用synchronized。

2. 线程池使用不当

误区一：选择不合适的线程池类型 Java提供了多种类型的线程池，如newFixedThreadPool、newCachedThreadPool、newSingleThreadExecutor等。每种类型的线程池适用于不同的场景。例如，newFixedThreadPool适用于需要控制并发线程数量的场景，newCachedThreadPool适用于任务执行时间短且数量不确定的场景。如果选择不合适的线程池类型，可能会导致性能问题。比如，在任务执行时间较长且并发量较大的情况下使用newCachedThreadPool，可能会创建大量线程，耗尽系统资源。

误区二：不设置合理的线程池参数 对于自定义的线程池，需要设置合理的核心线程数、最大线程数、队列容量等参数。如果核心线程数设置过小，可能导致任务长时间等待；如果最大线程数设置过大，可能会耗尽系统资源。例如，在一个I/O密集型任务中，如果核心线程数设置为1，可能会导致大量I/O操作等待，降低系统性能。

3. 对锁机制的错误理解

误区一：认为锁的粒度越小越好 虽然减小锁的粒度可以提高并发性能，但如果锁的粒度过小，可能会导致频繁的锁竞争和上下文切换，反而降低性能。例如，在一个对数组进行频繁操作的场景中，如果对每个数组元素的操作都加锁，锁竞争的频率会很高。正确的做法是根据业务逻辑，合理确定锁的粒度，在保证线程安全的前提下，尽量减少锁竞争。

误区二：忘记释放锁 在使用java.util.concurrent.locks.Lock接口时，如果在获取锁后忘记在finally块中释放锁，可能会导致死锁。例如：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockReleaseMistake {
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 1 acquired lock");
                // 忘记在finally块中释放锁
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread thread2 = new Thread(() -> {
            lock.lock();
            try {
                System.out.println("Thread 2 trying to acquire lock");
                // 线程2将永远等待，因为线程1没有释放锁
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        });

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

在上述代码中，thread1获取锁后没有在finally块中释放锁，导致thread2永远等待，形成死锁。

4. 错误处理线程异常

误区一：在多线程中忽略异常 在多线程编程中，如果一个线程抛出异常而没有被捕获，该线程会终止，可能会导致程序出现意想不到的结果。例如：

public class UncaughtExceptionExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            int result = 10 / 0; // 抛出ArithmeticException
            System.out.println("Result: " + result);
        });

        thread.start();

        System.out.println("Main thread continues");
    }
}

在上述代码中，thread线程抛出ArithmeticException异常，但没有被捕获，线程终止。而main线程继续执行，可能会导致程序后续逻辑出现问题。

正确的做法是在每个线程中捕获异常，或者为线程设置UncaughtExceptionHandler。例如：

public class UncaughtExceptionHandlerExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            int result = 10 / 0; // 抛出ArithmeticException
            System.out.println("Result: " + result);
        });

        thread.setUncaughtExceptionHandler((t, e) -> {
            System.out.println("Thread " + t.getName() + " threw an exception: " + e.getMessage());
        });

        thread.start();

        System.out.println("Main thread continues");
    }
}

在这个例子中，通过设置UncaughtExceptionHandler，可以在主线程中捕获并处理子线程抛出的异常，避免程序出现意外终止。

5. 对线程可见性和有序性的误解

误区一：认为局部变量一定是线程安全的 虽然局部变量通常被认为是线程安全的，因为每个线程都有自己的栈空间。但如果局部变量指向一个共享对象，并且多个线程对该对象进行操作，就可能会出现线程安全问题。例如：

public class LocalVariableMistake {
    public static void main(String[] args) {
        class Inner {
            int value = 0;
        }

        Inner inner = new Inner();
        Thread thread1 = new Thread(() -> {
            Inner localInner = inner;
            localInner.value++;
        });

        Thread thread2 = new Thread(() -> {
            Inner localInner = inner;
            System.out.println("Value: " + localInner.value);
        });

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

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

在上述代码中，虽然localInner是局部变量，但它指向的inner对象是共享的。thread1对localInner.value的修改可能不会及时被thread2看到，导致thread2打印出的value值不是预期的1。

误区二：忽略指令重排序 Java内存模型允许编译器和处理器对指令进行重排序，以提高性能。但在多线程环境下，指令重排序可能会导致程序出现意想不到的结果。例如：

public class InstructionReorderingMistake {
    private static int a = 0;
    private static int b = 0;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000000; i++) {
            a = 0;
            b = 0;
            Thread thread1 = new Thread(() -> {
                a = 1;
                b = 2;
            });

            Thread thread2 = new Thread(() -> {
                if (b == 2) {
                    System.out.println("a = " + a);
                }
            });

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

            thread1.join();
            thread2.join();
        }
    }
}

在上述代码中，理论上如果b == 2，那么a应该为1。但由于指令重排序，thread1可能先执行b = 2，再执行a = 1，导致thread2打印出a = 0。为了避免这种情况，可以使用volatile关键字或其他同步机制来保证指令的顺序性。

通过了解这些最佳实践和常见误区，可以帮助开发者编写出更高效、更健壮的Java多线程程序。在实际开发中，需要根据具体的业务需求和场景，选择合适的多线程编程技术和策略。