java方法同步

最新推荐文章于 2023-03-30 13:01:58 发布

转载最新推荐文章于 2023-03-30 13:01:58 发布 · 786 阅读

本文详细介绍了Java中的同步机制，包括同步方法和同步块的概念及其使用方法。此外还对比了synchronized关键字与Lock接口的区别，并探讨了如何避免死锁。最后，文章通过实现一个简单的线程池示例，展示了多线程编程的技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java同步

分类： Java 2011-09-06 21:15 100人阅读评论(0) 收藏举报

同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中，程序不会产生设计之外的错误结果。同步的实现方式有两种，同步方法和同步块，这两种方式都要用到synchronized关键字。

给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。下面代码是一个同步方法的示例

[java] view plain copy print ?

public synchronized void aMethod() {
// do something
}
public static synchronized void anotherMethod() {
// do something
}

public synchronized void aMethod() {    
    // do something    
}    
   
public static synchronized void anotherMethod() {    
    // do something    
}

线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。

同步块的形式虽然与同步方法不同，但是原理和效果是一致的。同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的 java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。

下面这段代码演示了同步块的实现方式：

[java] view plain copy print ?

public void test() {
// 同步锁
String lock = "LOCK";
// 同步块
synchronized (lock) {
// do something
}
int i = 0;
// ...
}

public void test() {    
    // 同步锁    
    String lock = "LOCK";    
   
    // 同步块    
    synchronized (lock) {    
        // do something    
    }    
   
    int i = 0;    
    // ...    
}

对于作为同步锁的对象并没有什么特别要求，任意一个对象都可以。如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。

synchronized和Lock

Lock是一个接口，它位于 Java 5.0新增的 java.utils.concurrent包的子包locks中。concurrent包及其子包中的类都是用来处理多线程编程的。实现Lock接口的类具有与synchronized关键字同样的功能，但是它更加强大一些。 java.utils.concurrent.locks.ReentrantLock是较常用的实现了Lock接口的类。下面是ReentrantLock类的一个应用实例：

[java] view plain copy print ?

private Lock lock = new ReentrantLock();
public void testLock() {
// 锁定对象
lock.lock();
try {
// do something
} finally {
// 释放对对象的锁定
lock.unlock();
}
}

private Lock lock = new ReentrantLock();    
   
public void testLock() {    
    // 锁定对象    
    lock.lock();    
    try {    
        // do something    
    } finally {    
        // 释放对对象的锁定    
        lock.unlock();    
    }    
}

lock()方法用于锁定对象，unlock()方法用于释放对对象的锁定，他们都是在Lock接口中定义的方法。位于这两个方法之间的代码在被执行时，效果等同于被放在synchronized同步块中。一般用法是将需要在lock()和unlock()方法之间执行的代码放在try{}块中，并且在finally{}块中调用unlock()方法，这样就可以保证即使在执行代码抛出异常的情况下，对象的锁也总是会被释放，否则的话就会为死锁的产生增加可能。

使用synchronized关键字实现的同步，会把一个对象的所有同步方法和同步块看做一个整体，只要有一个被某个线程调用了，其他的就无法被别的线程执行，即使这些方法或同步块与被调用的代码之间没有任何逻辑关系，这显然降低了程序的运行效率。而使用Lock就能够很好地解决这个问题。我们可以把一个对象中按照逻辑关系把需要同步的方法或代码进行分组，为每个组创建一个Lock类型的对象，对实现同步。那么，当一个同步块被执行时，这个线程只会锁定与当前运行代码相关的其他代码最小集合，而并不影响其他线程对其余同步代码的调用执行。

关于死锁

死锁就是一个进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源，从而导致所有线程都无法继续执行的情况。死锁是多线程编程中一个隐藏的陷阱，它经常发生在多个线程共用资源的时候。在实际开发中，死锁一般隐藏的较深，不容易被发现，一旦死锁现象发生，就必然会导致程序的瘫痪。因此必须避免它的发生。

程序中必须同时满足以下四个条件才会引发死锁：

互斥（Mutual exclusion）：线程所使用的资源中至少有一个是不能共享的，它在同一时刻只能由一个线程使用。
持有与等待（Hold and wait）：至少有一个线程已经持有了资源，并且正在等待获取其他的线程所持有的资源。
非抢占式（No pre-emption）：如果一个线程已经持有了某个资源，那么在这个线程释放这个资源之前，别的线程不能把它抢夺过去使用。
循环等待（Circular wait）：假设有N个线程在运行，第一个线程持有了一个资源，并且正在等待获取第二个线程持有的资源，而第二个线程正在等待获取第三个线程持有的资源，依此类推……第N个线程正在等待获取第一个线程持有的资源，由此形成一个循环等待。

线程池

线程池就像数据库连接池一样，是一个对象池。所有的对象池都有一个共同的目的，那就是为了提高对象的使用率，从而达到提高程序效率的目的。比如对于Servlet，它被设计为多线程的（如果它是单线程的，你就可以想象，当1000个人同时请求一个网页时，在第一个人获得请求结果之前，其它999个人都在郁闷地等待），如果为每个用户的每一次请求都创建一个新的线程对象来运行的话，系统就会在创建线程和销毁线程上耗费很大的开销，大大降低系统的效率。因此，Servlet多线程机制背后有一个线程池在支持，线程池在初始化初期就创建了一定数量的线程对象，通过提高对这些对象的利用率，避免高频率地创建对象，从而达到提高程序的效率的目的。

下面实现一个最简单的线程池，从中理解它的实现原理。为此我们定义了四个类，它们的用途及具体实现如下：
Task（任务）：这是个代表任务的抽象类，其中定义了一个deal()方法，继承Task抽象类的子类需要实现这个方法，并把这个任务需要完成的具体工作在deal()方法编码实现。线程池中的线程之所以被创建，就是为了执行各种各样数量繁多的任务的，为了方便线程对任务的处理，我们需要用Task抽象类来保证任务的具体工作统一放在deal()方法里来完成，这样也使代码更加规范。
Task的定义如下：

[java] view plain copy print ?

public abstract class Task {
public enum State {
/* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED
}
// 任务状态
private State state = State.NEW;
public void setState(State state) {
this.state = state;
}
public State getState() {
return state;
}
public abstract void deal();
}

public abstract class Task {    
    public enum State {    
        /* 新建 */NEW, /* 执行中 */RUNNING, /* 已完成 */FINISHED    
    }    
   
    // 任务状态    
    private State state = State.NEW;    
   
    public void setState(State state) {    
        this.state = state;    
    }    
   
    public State getState() {    
        return state;    
    }    
   
    public abstract void deal();    
}

TaskQueue（任务队列）：在同一时刻，可能有很多任务需要执行，而程序在同一时刻只能执行一定数量的任务，当需要执行的任务数超过了程序所能承受的任务数时怎么办呢？这就有了先执行哪些任务，后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种，它采用的是FIFO（先进先出，英文名是First In First Out）的方式，也就是按照任务到达的先后顺序执行。
TaskQueue类的定义如下：

[java] view plain copy print ?

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class TaskQueue {
private List<Task> queue = new LinkedList<Task>();
// 添加一项任务
public synchronized void addTask(Task task) {
if (task != null) {
queue.add(task);
}
}
// 完成任务后将它从任务队列中删除
public synchronized void finishTask(Task task) {
if (task != null) {
task.setState(Task.State.FINISHED);
queue.remove(task);
}
}
// 取得一项待执行任务
public synchronized Task getTask() {
Iterator<Task> it = queue.iterator();
Task task;
while (it.hasNext()) {
task = it.next();
// 寻找一个新建的任务
if (Task.State.NEW.equals(task.getState())) {
// 把任务状态置为运行中
task.setState(Task.State.RUNNING);
return task;
}
}
return null;
}
}

import java.util.Iterator;    
import java.util.LinkedList;    
import java.util.List;    
   
public class TaskQueue {    
    private List<Task> queue = new LinkedList<Task>();    
   
    // 添加一项任务    
    public synchronized void addTask(Task task) {    
        if (task != null) {    
            queue.add(task);    
        }    
    }    
   
    // 完成任务后将它从任务队列中删除    
    public synchronized void finishTask(Task task) {    
        if (task != null) {    
            task.setState(Task.State.FINISHED);    
            queue.remove(task);    
        }    
    }    
   
    // 取得一项待执行任务    
    public synchronized Task getTask() {    
        Iterator<Task> it = queue.iterator();    
        Task task;    
        while (it.hasNext()) {    
            task = it.next();    
            // 寻找一个新建的任务    
            if (Task.State.NEW.equals(task.getState())) {    
                // 把任务状态置为运行中    
                task.setState(Task.State.RUNNING);    
                return task;    
            }    
        }    
        return null;    
    }    
}

[java] view plain copy print ?

<SPAN style="FONT-FAMILY: Arial, Verdana, sans-serif; WHITE-SPACE: normal">addTask(Task task)方法用于当一个新的任务到达时，将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时，将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。</SPAN>

addTask(Task task)方法用于当一个新的任务到达时，将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。finishTask(Task task)方法用于任务被执行完毕时，将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。

TaskThread（执行任务的线程）：它继承自Thread类，专门用于执行任务队列中的待执行任务。
[java] view plain copy print ?
1. public class TaskThread extends Thread {
2. // 该线程所属的线程池
3. private ThreadPoolService service;
5. public TaskThread(ThreadPoolService tps) {
6. service = tps;
7. }
9. public void run() {
10. // 在线程池运行的状态下执行任务队列中的任务
11. while (service.isRunning()) {
12. TaskQueue queue = service.getTaskQueue();
13. Task task = queue.getTask();
14. if (task != null) {
15. task.deal();
16. }
17. queue.finishTask(task);
18. }
19. }
20. }
```
public class TaskThread extends Thread {    
    // 该线程所属的线程池    
    private ThreadPoolService service;    
   
    public TaskThread(ThreadPoolService tps) {    
        service = tps;    
    }    
   
    public void run() {    
        // 在线程池运行的状态下执行任务队列中的任务    
        while (service.isRunning()) {    
            TaskQueue queue = service.getTaskQueue();    
            Task task = queue.getTask();    
            if (task != null) {    
                task.deal();    
            }    
            queue.finishTask(task);    
        }    
    }    
}   
```
ThreadPoolService（线程池服务类）：这是线程池最核心的一个类。它在被创建了时候就创建了几个线程对象，但是这些线程并没有启动运行，但调用了start()方法启动线程池服务时，它们才真正运行。stop()方法可以停止线程池服务，同时停止池中所有线程的运行。而runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。

ThreadPoolService类的定义如下：
[java] view plain copy print ?
1. import java.util.ArrayList;
2. import java.util.List;
4. public class ThreadPoolService {
5. // 线程数
6. public static final int THREAD_COUNT = 5;
8. // 线程池状态
9. private Status status = Status.NEW;
11. private TaskQueue queue = new TaskQueue();
13. public enum Status {
14. /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,
15. }
17. private List<Thread> threads = new ArrayList<Thread>();
19. public ThreadPoolService() {
20. for (int i = 0; i < THREAD_COUNT; i++) {
21. Thread t = new TaskThread(this);
22. threads.add(t);
23. }
24. }
26. // 启动服务
27. public void start() {
28. this.status = Status.RUNNING;
29. for (int i = 0; i < THREAD_COUNT; i++) {
30. threads.get(i).start();
31. }
32. }
34. // 停止服务
35. public void stop() {
36. this.status = Status.TERMINATED;
37. }
39. // 是否正在运行
40. public boolean isRunning() {
41. return status == Status.RUNNING;
42. }
44. // 执行任务
45. public void runTask(Task task) {
46. queue.addTask(task);
47. }
49. protected TaskQueue getTaskQueue() {
50. return queue;
51. }
52. }
```
import java.util.ArrayList;    
import java.util.List;    
   
public class ThreadPoolService {    
    // 线程数    
    public static final int THREAD_COUNT = 5;    
   
    // 线程池状态    
    private Status status = Status.NEW;    
   
    private TaskQueue queue = new TaskQueue();    
   
    public enum Status {    
        /* 新建 */NEW, /* 提供服务中 */RUNNING, /* 停止服务 */TERMINATED,    
    }    
   
    private List<Thread> threads = new ArrayList<Thread>();    
   
    public ThreadPoolService() {    
        for (int i = 0; i < THREAD_COUNT; i++) {    
            Thread t = new TaskThread(this);    
            threads.add(t);    
        }    
    }    
   
    // 启动服务    
    public void start() {    
        this.status = Status.RUNNING;    
        for (int i = 0; i < THREAD_COUNT; i++) {    
            threads.get(i).start();    
        }    
    }    
   
    // 停止服务    
    public void stop() {    
        this.status = Status.TERMINATED;    
    }    
   
    // 是否正在运行    
    public boolean isRunning() {    
        return status == Status.RUNNING;    
    }    
   
    // 执行任务    
    public void runTask(Task task) {    
        queue.addTask(task);    
    }    
   
    protected TaskQueue getTaskQueue() {    
        return queue;    
    }    
}   
```
完成了上面四个类，我们就实现了一个简单的线程池。现在我们就可以使用它了，下面的代码做了一个简单的示例：
[java] view plain copy print ?
1. public class SimpleTaskTest extends Task {
2. @Override
3. public void deal() {
4. // do something
5. }
7. public static void main(String[] args) throws InterruptedException {
8. ThreadPoolService service = n
9. }
10. }