线程和线程池有什么区别？

线程适用于少量、短期的任务执行，而线程池适用于大量、长期的任务执行。通过线程池管理线程，可以更高效地利用系统资源，提升系统性能和稳定性。

线程池 (ThreadPool)

• 定义: 线程池是一个管理线程的集合，通过复用固定数量的线程来执行多个任务，避免频繁创建和销毁线程的开销。
• 创建: 在 Java 中，可以使用 Executors 工具类来创建线程池，例如 FixedThreadPool、CachedThreadPool、ScheduledThreadPool 等。
• 管理: 线程池管理线程的创建、调度和生命周期，并通过队列来调度任务。
• 开销: 通过复用线程，减少了频繁创建和销毁线程的开销，提高了系统性能和资源利用率。
• 示例:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class Main {public static void main(String[] args) {ExecutorService executor = Executors.newFixedThreadPool(5);for (int i = 0; i < 10; i++) {Runnable task = new Runnable() {public void run() {// 线程任务}};executor.execute(task);}executor.shutdown();}
}

区别

1. 资源管理:

   • 线程: 每个任务创建一个新的线程，线程的创建和销毁由程序员控制。
   • 线程池: 通过复用线程来执行多个任务，线程的创建和销毁由线程池管理。

2. 性能:

   • 线程: 频繁的线程创建和销毁会带来性能开销。
   • 线程池: 通过复用线程减少性能开销，提高系统性能。

3. 任务调度:

   • 线程: 任务由线程独立执行，每个线程有自己的执行路径。
   • 线程池: 任务由线程池调度和管理，通过队列来分配任务。

4. 生命周期:

   • 线程: 线程的生命周期独立管理，包括创建、运行、等待和终止。
   • 线程池: 线程的生命周期由线程池管理，线程池会自动管理线程的复用和销毁。

如何创建线程池？

在 Java 中，创建线程池通常使用 java.util.concurrent.Executors 工具类。Executors 提供了一些工厂方法来创建不同类型的线程池。以下是一些常见的线程池类型及其创建方法：

1. 固定大小线程池 (Fixed Thread Pool)

固定大小线程池使用固定数量的线程来执行任务。适用于任务数量已知且不会动态增加的情况。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class FixedThreadPoolExample {public static void main(String[] args) {// 创建一个包含5个线程的固定大小线程池ExecutorService executor = Executors.newFixedThreadPool(5);for (int i = 0; i < 10; i++) {Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");}};// 提交任务给线程池执行executor.execute(task);}// 关闭线程池executor.shutdown();}
}

2. 可缓存线程池 (Cached Thread Pool)

可缓存线程池根据需要创建新线程，并在先前创建的线程空闲时重用它们。适用于大量短期任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CachedThreadPoolExample {public static void main(String[] args) {// 创建一个可缓存的线程池ExecutorService executor = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");}};// 提交任务给线程池执行executor.execute(task);}// 关闭线程池executor.shutdown();}
}

3. 单线程线程池 (Single Thread Pool)

单线程线程池只有一个线程来执行任务。适用于需要保证任务按顺序执行的情况。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class SingleThreadPoolExample {public static void main(String[] args) {// 创建一个单线程的线程池ExecutorService executor = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");}};// 提交任务给线程池执行executor.execute(task);}// 关闭线程池executor.shutdown();}
}

4. 定时线程池 (Scheduled Thread Pool)

定时线程池可以在指定的延迟后或定期执行任务。适用于需要定时或周期性执行任务的情况。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledThreadPoolExample {public static void main(String[] args) {// 创建一个包含5个线程的定时线程池ScheduledExecutorService executor = Executors.newScheduledThreadPool(5);Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");}};// 在3秒后执行一次性任务executor.schedule(task, 3, TimeUnit.SECONDS);// 每2秒执行一次任务，首次延迟1秒executor.scheduleAtFixedRate(task, 1, 2, TimeUnit.SECONDS);// 每2秒执行一次任务，上次任务结束后等待2秒再执行executor.scheduleWithFixedDelay(task, 1, 2, TimeUnit.SECONDS);// 添加延迟以便观察任务执行效果，然后关闭线程池try {Thread.sleep(10000); // 延迟10秒以便观察任务执行} catch (InterruptedException e) {e.printStackTrace();}executor.shutdown();}
}

推荐使用哪种方式来创建线程池？

推荐使用 java.util.concurrent.ThreadPoolExecutor 类来创建线程池，因为它提供了高度的灵活性和配置选项，可以满足各种复杂的并发需求。虽然 Executors 工具类提供了便捷的方法来创建不同类型的线程池，但直接使用 ThreadPoolExecutor 可以更好地控制线程池的行为和参数。

使用 ThreadPoolExecutor 创建线程池

ThreadPoolExecutor 构造方法允许你指定线程池的各种参数：

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler
)

说一下 ThreadPoolExecutor 的参数含义？

参数解释

• corePoolSize: 线程池维护的最小线程数，即使这些线程处于空闲状态。
• maximumPoolSize: 线程池允许的最大线程数。
• keepAliveTime: 当线程数超过 corePoolSize 时，多余的空闲线程的存活时间。
• unit: keepAliveTime 的时间单位。
• workQueue: 用来存储等待执行任务的队列。
• threadFactory: 用来创建新线程的工厂。
• handler: 处理无法执行的任务的策略。

示例代码

import java.util.concurrent.*;public class CustomThreadPoolExample {public static void main(String[] args) {int corePoolSize = 5;int maximumPoolSize = 10;long keepAliveTime = 60;TimeUnit unit = TimeUnit.SECONDS;BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100);ThreadFactory threadFactory = Executors.defaultThreadFactory();RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);for (int i = 0; i < 20; i++) {Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");}};executor.execute(task);}executor.shutdown();}
}

常见的线程池类型及其配置

如果你希望使用类似于 Executors 提供的便捷线程池配置，可以参考以下配置：

1. 固定大小线程池

ThreadPoolExecutor fixedThreadPool = new ThreadPoolExecutor(5,  // corePoolSize5,  // maximumPoolSize (same as corePoolSize)0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()
);

2. 可缓存线程池

ThreadPoolExecutor cachedThreadPool = new ThreadPoolExecutor(0,  // corePoolSizeInteger.MAX_VALUE,  // maximumPoolSize60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>()
);

3. 单线程线程池

ThreadPoolExecutor singleThreadPool = new ThreadPoolExecutor(1,  // corePoolSize1,  // maximumPoolSize0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()
);

4. 定时线程池

ScheduledThreadPoolExecutor scheduledThreadPool = new ScheduledThreadPoolExecutor(5);

说一下线程池的执行流程

线程池的执行流程可以分为以下几个步骤，从任务提交到任务执行完毕，每一步都有明确的操作过程。以下是一个典型的线程池执行流程：

1. 任务提交

当一个任务（Runnable 或 Callable）被提交给线程池时，通过 execute() 或 submit() 方法，任务会被包装成一个 FutureTask 对象（如果使用 submit() 方法）。

2. 判断线程数

线程池判断当前运行的线程数是否小于核心线程数（corePoolSize）。

• 如果是，创建一个新的线程来执行任务。
• 如果不是，将任务放入任务队列（workQueue）。

3. 任务队列

• 如果任务队列未满，任务被放入队列等待执行。
• 如果任务队列已满，线程池会判断当前运行的线程数是否小于最大线程数（maximumPoolSize）。
  • 如果是，创建一个新的线程来执行任务。
  • 如果不是，执行拒绝策略（RejectedExecutionHandler），如抛出异常、调用任务的 run() 方法直接在提交线程中执行等。

4. 任务执行

任务由线程池中的工作线程从任务队列中取出并执行。每个工作线程不断循环从任务队列中获取任务并执行，直到线程池被关闭。

5. 线程复用

线程池中的线程执行完任务后不会立即销毁，而是继续从任务队列中获取新的任务执行。这种线程复用机制大大减少了线程创建和销毁的开销。

6. 空闲线程处理

当线程池中的线程数超过核心线程数且这些超出部分的线程处于空闲状态超过指定的存活时间（keepAliveTime）时，这些线程将被销毁，直到线程池中的线程数不超过核心线程数。

7. 线程池关闭

当线程池被调用 shutdown() 方法时，不再接受新的任务，但会继续执行已提交的任务，直到任务队列中的所有任务执行完毕。当调用 shutdownNow() 方法时，线程池会试图停止所有正在执行的任务，并清空任务队列。

线程池执行流程示意图

            任务提交|v判断线程数 < corePoolSize ?/ \是    否/       \创建新线程    任务放入队列|v任务队列已满？/ \是    否/       \判断线程数 < maximumPoolSize ?/ \是    否/       \创建新线程    执行拒绝策略|v任务执行|v线程复用|v空闲线程处理|v线程池关闭

示例代码

以下是一个示例代码，展示了如何创建和使用线程池以及解释线程池的执行流程：

import java.util.concurrent.*;public class ThreadPoolExample {public static void main(String[] args) {// 创建一个包含5个核心线程，10个最大线程，和60秒存活时间的线程池ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(100),Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());// 提交20个任务给线程池for (int i = 0; i < 20; i++) {Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");try {Thread.sleep(2000); // 模拟任务执行时间} catch (InterruptedException e) {e.printStackTrace();}}};executor.execute(task);}// 关闭线程池executor.shutdown();try {// 等待线程池中的所有任务执行完毕if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {executor.shutdownNow(); // 强制关闭}} catch (InterruptedException e) {executor.shutdownNow(); // 强制关闭}}
}

线程池的拒绝策略都有哪些

线程池的拒绝策略定义了当任务不能被执行时应采取的措施。当线程池已达到其最大容量，且任务队列也已满时，线程池会调用拒绝策略。Java 的 java.util.concurrent 包提供了几种内置的拒绝策略，具体如下：

1. AbortPolicy（默认策略）

AbortPolicy 直接抛出 RejectedExecutionException 异常，阻止系统正常工作。

RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

2. CallerRunsPolicy

CallerRunsPolicy 会让提交任务的线程自己来运行这个任务。这种策略提供了一种退化机制，可以降低新任务的提交速度，从而减缓新任务的生成。

RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();

3. DiscardPolicy

DiscardPolicy 直接丢弃无法执行的任务，不予处理，也不抛出异常。

RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardPolicy();

4. DiscardOldestPolicy

DiscardOldestPolicy 会丢弃队列中最老的任务（即最早加入队列的任务），然后尝试重新提交被拒绝的任务。

RejectedExecutionHandler handler = new ThreadPoolExecutor.DiscardOldestPolicy();

5. 自定义拒绝策略

你也可以实现自己的拒绝策略，通过实现 RejectedExecutionHandler 接口并覆盖 rejectedExecution 方法。

如何实现自定义拒绝策略？

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;public class CustomRejectedExecutionHandler implements RejectedExecutionHandler {@Overridepublic void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {// 自定义处理逻辑System.out.println("Task " + r.toString() + " rejected from " + executor.toString());// 可以记录日志，或者执行其他处理措施}
}

然后在创建 ThreadPoolExecutor 时使用自定义的拒绝策略：

RejectedExecutionHandler handler = new CustomRejectedExecutionHandler();
ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);

示例代码

以下是一个示例，展示了如何创建线程池并使用不同的拒绝策略：

import java.util.concurrent.*;public class RejectedExecutionExample {public static void main(String[] args) {int corePoolSize = 2;int maximumPoolSize = 4;long keepAliveTime = 10;TimeUnit unit = TimeUnit.SECONDS;BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(2);// 使用不同的拒绝策略RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy(); // 改为不同的策略进行测试ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);for (int i = 0; i < 10; i++) {Runnable task = new Runnable() {public void run() {System.out.println(Thread.currentThread().getName() + " is executing task");try {Thread.sleep(2000); // 模拟任务执行时间} catch (InterruptedException e) {e.printStackTrace();}}};try {executor.execute(task);} catch (RejectedExecutionException e) {System.out.println("Task " + i + " rejected");}}executor.shutdown();try {if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {executor.shutdownNow();}} catch (InterruptedException e) {executor.shutdownNow();}}
}

线程池中 shutdownNow() 和 shutdown() 有什么区别？

在 Java 的线程池中，shutdown() 和 shutdownNow() 方法都用于关闭线程池，但它们的行为有显著不同。

• shutdown(): 有序关闭，不接受新任务，但会完成已提交的任务。
• shutdownNow(): 立即关闭，尽力中断正在执行的任务，并返回未执行的任务列表。

选择使用哪种关闭方法取决于应用场景和具体需求。如果需要确保所有任务都执行完毕，应使用 shutdown()；如果需要尽快停止线程池，则使用 shutdownNow()。

shutdown()

• 行为: 启动有序关闭，线程池不再接受新任务，但会继续处理已提交的任务，包括那些已提交但尚未开始执行的任务和正在执行的任务。
• 工作线程: 线程池中的工作线程在执行完当前任务后将继续从队列中取出并执行任务，直到所有任务完成。
• 调用效果: 调用此方法后，线程池将继续运行直到所有任务完成，然后才终止。

shutdownNow()

• 行为: 尝试立即停止线程池的所有活动任务，并返回等待执行的任务列表。它会尽力中断正在执行的任务，并不保证能成功中断所有任务。
• 工作线程: 线程池中的工作线程会被尝试中断。已提交但尚未开始执行的任务将不会被执行，并返回这些任务的列表。
• 调用效果: 调用此方法后，线程池会立即停止接受新任务，尽力中断所有正在执行的任务，清空任务队列，并返回队列中未执行的任务。

示例代码

以下代码展示了如何使用 shutdown() 和 shutdownNow() 方法，以及它们的不同效果：

import java.util.concurrent.*;public class ThreadPoolShutdownExample {public static void main(String[] args) throws InterruptedException {ExecutorService executor = Executors.newFixedThreadPool(3);for (int i = 0; i < 5; i++) {executor.execute(new RunnableTask(i));}// 使用 shutdown() 方法System.out.println("Calling shutdown()");executor.shutdown();// 等待线程池终止if (executor.awaitTermination(5, TimeUnit.SECONDS)) {System.out.println("All tasks completed");} else {System.out.println("Timeout reached before termination");}// 重新创建线程池executor = Executors.newFixedThreadPool(3);for (int i = 0; i < 5; i++) {executor.execute(new RunnableTask(i));}// 使用 shutdownNow() 方法System.out.println("Calling shutdownNow()");List<Runnable> notExecutedTasks = executor.shutdownNow();System.out.println("Tasks not executed: " + notExecutedTasks.size());// 等待线程池终止if (executor.awaitTermination(5, TimeUnit.SECONDS)) {System.out.println("All tasks terminated");} else {System.out.println("Timeout reached before termination");}}
}class RunnableTask implements Runnable {private int taskId;public RunnableTask(int taskId) {this.taskId = taskId;}@Overridepublic void run() {System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());try {Thread.sleep(2000); // 模拟任务执行时间} catch (InterruptedException e) {System.out.println("Task " + taskId + " was interrupted");}}@Overridepublic String toString() {return "RunnableTask{" + "taskId=" + taskId + '}';}
}

运行结果说明

• 调用 shutdown():

  • 线程池将处理所有已提交的任务，但不再接受新任务。
  • 输出表明所有任务执行完成。

• 调用 shutdownNow():

  • 尝试立即停止所有正在执行的任务，并返回未执行的任务列表。
  • 输出表明一些任务被中断，一些任务未被执行。

多线程存在什么问题？

多线程编程可以显著提高程序的性能和响应能力，但它也带来了许多复杂性和潜在的问题。以下是一些常见的多线程问题：

1. 线程安全问题

当多个线程同时访问和修改共享数据时，可能会发生线程安全问题。

竞态条件（Race Condition）

多个线程同时读取和修改共享数据，导致不可预测的结果。

示例

class Counter {private int count = 0;public void increment() {count++;}public int getCount() {return count;}
}public class RaceConditionExample {public static void main(String[] args) throws InterruptedException {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();thread1.join();thread2.join();System.out.println("Final count: " + counter.getCount());}
}

在这个示例中，Counter 类没有同步机制，可能导致竞态条件，最终的计数结果可能不是预期的 2000。

2. 死锁（Deadlock）

两个或多个线程相互等待对方持有的资源，从而进入无限等待状态。

示例

class Resource {private final String name;public Resource(String name) {this.name = name;}public synchronized void use(Resource other) {System.out.println(Thread.currentThread().getName() + " using " + name);try {Thread.sleep(50); // 模拟工作} catch (InterruptedException e) {e.printStackTrace();}other.doSomething();}public synchronized void doSomething() {System.out.println(Thread.currentThread().getName() + " doing something with " + name);}
}public class DeadlockExample {public static void main(String[] args) {final Resource resourceA = new Resource("ResourceA");final Resource resourceB = new Resource("ResourceB");Thread thread1 = new Thread(() -> resourceA.use(resourceB), "Thread1");Thread thread2 = new Thread(() -> resourceB.use(resourceA), "Thread2");thread1.start();thread2.start();}
}

在这个示例中，Thread1 持有 resourceA 并等待 resourceB，而 Thread2 持有 resourceB 并等待 resourceA，导致死锁。

3. 活锁（Livelock）

线程频繁地让出资源，但由于某种条件无法满足，导致线程不能继续执行。

示例

活锁的示例较为复杂，通常涉及多个线程不断改变状态以响应对方的行为，但始终无法取得进展。

4. 资源饥饿（Resource Starvation）

某些线程长时间得不到所需资源，导致无法继续执行。

示例

一个优先级较低的线程可能会因为优先级高的线程一直占用资源而无法获得运行机会。

5. 线程泄漏（Thread Leakage）

线程启动后没有正常结束，且没有被正确管理和回收，导致资源浪费。

6. 竞态条件引发的难以复现的错误

多线程程序中的竞态条件往往导致难以复现的间歇性错误，增加调试难度。

7. 内存可见性问题

在多核处理器上，线程可能在各自的缓存中看到不同步的内存视图，导致读取到过期的数据。

示例

class VisibilityProblem {private volatile boolean running = true;public void run() {while (running) {// ...}System.out.println("Stopped.");}public void stop() {running = false;}public static void main(String[] args) throws InterruptedException {VisibilityProblem visibilityProblem = new VisibilityProblem();Thread thread = new Thread(visibilityProblem::run);thread.start();Thread.sleep(1000);visibilityProblem.stop();}
}

在这个示例中，通过使用 volatile 关键字确保 running 变量的可见性，保证 stop() 方法调用后，run() 方法可以及时感知到变化。

8. 过度同步（Over-synchronization）

过度使用同步机制会导致性能下降和线程争用（Contention），增加系统开销。

9. 中断和恢复问题

线程在执行过程中被中断，需要正确处理中断信号，确保程序的健壮性。

解决多线程问题的建议

• 使用高层次的并发工具（如 java.util.concurrent 包中的类）。
• 避免手动管理线程，使用线程池来管理线程的创建和销毁。
• 使用正确的同步机制，如 synchronized，Lock，以及 volatile。
• 尽量减少共享数据，使用线程安全的数据结构（如 ConcurrentHashMap）。
• 小心处理线程中断和恢复，确保在中断时进行必要的清理工作。
• 避免死锁，尽量使用锁的顺序，或者使用尝试锁定（如 tryLock）来避免死锁。
• 进行充分的测试，尤其是并发测试，模拟实际的多线程环境来发现潜在的问题。

多线程编程复杂且容易出错，但通过合理的设计和工具，可以有效地利用多核处理器的能力，提高程序性能。

为什么会有线程安全问题？

线程安全问题主要出现在多线程编程中，当多个线程同时访问共享资源时，如果不加以控制和协调，就可能导致数据的不一致性和不可预测的行为。以下是一些导致线程安全问题的常见原因：

1. 共享可变数据：
   当多个线程同时读写同一个共享变量时，如果没有适当的同步机制，就可能导致数据竞争（Race Condition）。例如，两个线程同时对一个计数器进行递增操作，可能会导致最终的计数结果不正确。

2. 原子性：
   某些操作在多线程环境下需要确保其原子性，即操作要么全部执行完毕，要么完全不执行。缺乏原子性会导致部分执行的操作留下不一致的状态。

3. 可见性：
   在多线程环境中，一个线程对共享变量的修改可能对其他线程不可见。现代处理器和编译器可能会对代码进行优化，导致一个线程对变量的更新不会立即被其他线程看到。这种情况下，程序可能会基于过时的数据做出错误的决策。

4. 有序性：
   多线程环境下，程序的执行顺序可能与代码的书写顺序不同。编译器、处理器和内存模型可能会重新排序指令，导致实际执行顺序与预期不一致，从而引发线程安全问题。

如何解决线程安全问题？

为了解决线程安全问题，可以使用以下方法：

• 锁（Lock）：使用互斥锁（如Java中的ReentrantLock）或同步块（如Java中的synchronized关键字）来确保同一时间只有一个线程可以访问共享资源。
• 原子变量：使用原子类（如Java中的AtomicInteger）来保证对单个变量的原子性操作。
• 线程本地存储：使用线程本地变量（如Java中的ThreadLocal）来确保每个线程都有自己的独立副本，避免共享数据。
• 不可变对象：使用不可变对象（如Java中的String和Integer）来避免修改共享数据。

synchronized 有几种用法？

在Java中，synchronized关键字用于实现线程同步，确保在同一时间只有一个线程可以访问被同步的代码块或方法。synchronized有以下几种用法：

1. 同步实例方法：
   使用synchronized关键字修饰实例方法，表示整个方法是同步的，只有一个线程可以访问这个方法的实例。

   public class Example {public synchronized void syncMethod() {// 同步方法的代码}
   }
   

2. 同步静态方法：
   使用synchronized关键字修饰静态方法，表示整个方法是同步的，只有一个线程可以访问这个方法的类。

   public class Example {public static synchronized void syncStaticMethod() {// 同步静态方法的代码}
   }
   

3. 同步代码块：
   使用synchronized关键字同步代码块，可以指定具体的对象作为锁。这种方式更灵活，可以选择只同步某些关键部分的代码。

   public class Example {private final Object lock = new Object();public void syncBlock() {synchronized (lock) {// 同步代码块的代码}}
   }
   

   也可以使用this作为锁，来同步当前实例的代码块：

   public class Example {public void syncBlock() {synchronized (this) {// 同步代码块的代码}}
   }
   

4. 类对象锁：
   使用Class对象作为锁，来同步静态方法或代码块，确保同一时间只有一个线程可以访问这个类的静态资源。

   public class Example {public void syncClassBlock() {synchronized (Example.class) {// 同步类对象锁的代码块}}
   }
   

synchronized 修饰静态方法和普通方法有什么区别吗？

synchronized修饰静态方法和普通方法的主要区别在于锁的对象不同，从而影响了线程同步的范围和粒度：

1. 锁的对象：

   • 静态方法：当synchronized修饰静态方法时，锁是当前类的Class对象。例如，如果有一个类Example，那么锁是Example.class。这意味着同一时间只有一个线程可以执行该类的任意一个静态同步方法。
   • 普通方法：当synchronized修饰普通实例方法时，锁是当前实例对象（this）。这意味着同一时间只有一个线程可以执行该实例对象的任意一个同步实例方法，但多个线程可以同时执行同一个类的不同实例的同步方法。

2. 同步范围：

   • 静态方法：由于锁是类对象（Class），所以同步范围是整个类的所有静态方法。即使多个线程操作不同的实例，静态同步方法仍然会被同步。
   • 普通方法：由于锁是实例对象（this），所以同步范围是该实例对象的所有同步实例方法。不同实例的同步方法不会相互影响。

具体示例如下：

public class Example {// 静态同步方法public static synchronized void staticSyncMethod() {// 静态同步方法的代码}// 实例同步方法public synchronized void instanceSyncMethod() {// 实例同步方法的代码}
}public class Test {public static void main(String[] args) {Example obj1 = new Example();Example obj2 = new Example();// 线程1调用obj1的静态同步方法new Thread(() -> Example.staticSyncMethod()).start();// 线程2调用obj2的静态同步方法new Thread(() -> Example.staticSyncMethod()).start();// 线程3调用obj1的实例同步方法new Thread(() -> obj1.instanceSyncMethod()).start();// 线程4调用obj2的实例同步方法new Thread(() -> obj2.instanceSyncMethod()).start();}
}

在这个示例中：

• 线程1和线程2因为调用的是同一个类的静态同步方法，所以它们会互相阻塞，只有一个线程可以执行staticSyncMethod。
• 线程3和线程4因为调用的是不同实例的同步方法，所以它们不会互相阻塞，可以同时执行instanceSyncMethod。