疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java线程、多线程学习笔记


 

 
实现同步的方式
 
同步是多线程中的重要概念。同步的使用可以保证在多线程运行的环境中,程序不会产生设计之外的错误结果。同步的实现方式有两种,同步方法和同步块,这两种方式都要用到synchronized关键字。
 
给一个方法增加synchronized修饰符之后就可以使它成为同步方法,这个方法可以是静态方法和非静态方法,但是不能是抽象类的抽象方法,也不能是接口中的接口方法。下面代码是一个同步方法的示例:
Java代码
public synchronized void aMethod() {  
    // do something  
}  
  
public static synchronized void anotherMethod() {  
    // do something  
}  
 
线程在执行同步方法时是具有排它性的。当任意一个线程进入到一个对象的任意一个同步方法时,这个对象的所有同步方法都被锁定了,在此期间,其他任何线程都不能访问这个对象的任意一个同步方法,直到这个线程执行完它所调用的同步方法并从中退出,从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后,其他线程是可以访问这个对象的所有非同步方法的。
 
同步块的形式虽然与同步方法不同,但是原理和效果是一致的。同步块是通过锁定一个指定的对象,来对同步块中包含的代码进行同步;而同步方法是对这个方法块里的代码进行同步,而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢?那么线程锁定的就不是这个类的对象了,也不是这个类自身,而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间,所以静态同步方法只受它所属类的其它静态同步方法的制约,而跟这个类的实例(对象)没有关系。
 
下面这段代码演示了同步块的实现方式:
Java代码
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代码
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类型的对象,对实现同步。那么,当一个同步块被执行时,这个线程只会锁定与当前运行代码相关的其他代码最小集合,而并不影响其他线程对其余同步代码的调用执行。
关于死锁
 
死锁就是一个进程中的每个线程都在等待这个进程中的其他线程释放所占用的资源,从而导致所有线程都无法继续执行的情况。死锁是多线程编程中一个隐藏的陷阱,它经常发生在多个线程共用资源的时候。在实际开发中,死锁一般隐藏的较深,不容易被发现,一旦死锁现象发生,就必然会导致程序的瘫痪。因此必须避免它的发生。
 
程序中必须同时满足以下四个条件才会引发死锁:
 
1、互斥(Mutual exclusion):线程所使用的资源中至少有一个是不能共享的,它在同一时刻只能由一个线程使用。
2、持有与等待(Hold and wait):至少有一个线程已经持有了资源,并且正在等待获取其他的线程所持有的资源。
3、非抢占式(No pre-emption):如果一个线程已经持有了某个资源,那么在这个线程释放这个资源之前,别的线程不能把它抢夺过去使用。
4、循环等待(Circular wait):假设有N个线程在运行,第一个线程持有了一个资源,并且正在等待获取第二个线程持有的资源,而第二个线程正在等待获取第三个线程持有的资源,依此类推……第N个线程正在等待获取第一个线程持有的资源,由此形成一个循环等待。
 
线程池
 
线程池就像数据库连接池一样,是一个对象池。所有的对象池都有一个共同的目的,那就是为了提高对象的使用率,从而达到提高程序效率的目的。比如对于 Servlet,它被设计为多线程的(如果它是单线程的,你就可以想象,当1000个人同时请求一个网页时,在第一个人获得请求结果之前,其它999个人都在郁闷地等待),如果为每个用户的每一次请求都创建一个新的线程对象来运行的话,系统就会在创建线程和销毁线程上耗费很大的开销,大大降低系统的效率。因此,Servlet多线程机制背后有一个线程池在支持,线程池在初始化初期就创建了一定数量的线程对象,通过提高对这些对象的利用率,避免高频率地创建对象,从而达到提高程序的效率的目的。
 
下面实现一个最简单的线程池,从中理解它的实现原理。为此我们定义了四个类,它们的用途及具体实现如下:
 
1、Task(任务):这是个代表任务的抽象类,其中定义了一个deal()方法,继承Task抽象类的子类需要实现这个方法,并把这个任务需要完成的具体工作在deal()方法编码实现。线程池中的线程之所以被创建,就是为了执行各种各样数量繁多的任务的,为了方便线程对任务的处理,我们需要用Task抽象类来保证任务的具体工作统一放在deal()方法里来完成,这样也使代码更加规范。
Task的定义如下:
Java代码
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();  
}  
 
2、TaskQueue(任务队列):在同一时刻,可能有很多任务需要执行,而程序在同一时刻只能执行一定数量的任务,当需要执行的任务数超过了程序所能承受的任务数时怎么办呢?这就有了先执行哪些任务,后执行哪些任务的规则。TaskQueue类就定义了这些规则中的一种,它采用的是FIFO(先进先出,英文名是First In First Out)的方式,也就是按照任务到达的先后顺序执行。
TaskQueue类的定义如下:
Java代码
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;  
    }  
}  
 
addTask(Task task)方法用于当一个新的任务到达时,将它添加到任务队列中。这里使用了LinkedList类来保存任务到达的先后顺序。 finishTask(Task task)方法用于任务被执行完毕时,将它从任务队列中清除出去。getTask()方法用于取得当前要执行的任务。
3、TaskThread(执行任务的线程):它继承自Thread类,专门用于执行任务队列中的待执行任务。
Java代码
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);  
        }  
    }  
}  
 
4、ThreadPoolService(线程池服务类):这是线程池最核心的一个类。它在被创建了时候就创建了几个线程对象,但是这些线程并没有启动运行,但调用了start()方法启动线程池服务时,它们才真正运行。stop()方法可以停止线程池服务,同时停止池中所有线程的运行。而runTask(Task task)方法是将一个新的待执行任务交与线程池来运行。
ThreadPoolService类的定义如下:
Java代码
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代码
public class SimpleTaskTest extends Task {  
    @Override  
    public void deal() {  
        // do something  
    }  
  
    public static void main(String[] args) throws InterruptedException {  
        ThreadPoolService service = new ThreadPoolService();  
        service.start();  
        // 执行十次任务  
        for (int i = 0; i < 10; i++) {  
            service.runTask(new SimpleTaskTest());  
        }  
        // 睡眠1秒钟,等待所有任务执行完毕  
        Thread.sleep(1000);  
        service.stop();  
    }  
}  
 
当然,我们实现的是最简单的,这里只是为了演示线程池的实现原理。在实际应用中,根据情况的不同,可以做很多优化。比如:
 
1、调整任务队列的规则,给任务设置优先级,级别高的任务优先执行。
2、动态维护线程池,当待执行任务数量较多时,增加线程的数量,加快任务的执行速度;当任务较少时,回收一部分长期闲置的线程,减少对系统资源的消耗。
 
事实上Java5.0及以上版本已经为我们提供了线程池功能,无需再重新实现。这些类位于java.util.concurrent包中。
 
Executors类提供了一组创建线程池对象的方法,常用的有一下几个:
Java代码
public static ExecutorService newCachedThreadPool() {  
    // other code  
}  
  
public static ExecutorService newFixedThreadPool(int nThreads) {  
    // other code  
}  
  
public static ExecutorService newSingleThreadExecutor() {  
    // other code  
}  
 
newCachedThreadPool() 方法创建一个动态的线程池,其中线程的数量会根据实际需要来创建和回收,适合于执行大量短期任务的情况;newFixedThreadPool(int nThreads)方法创建一个包含固定数量线程对象的线程池,nThreads代表要创建的线程数,如果某个线程在运行的过程中因为异常而终止了,那么一个新的线程会被创建和启动来代替它;而newSingleThreadExecutor()方法则只在线程池中创建一个线程,来执行所有的任务。
 
这三个方法都返回了一个ExecutorService类型的对象。实际上,ExecutorService是一个接口,它的submit()方法负责接收任务并交与线程池中的线程去运行。submit()方法能够接受Callable和Runnable两种类型的对象。它们的用法和区别如下:
 
1、Runnable接口:继承Runnable接口的类要实现它的run()方法,并将执行任务的代码放入其中,run()方法没有返回值。适合于只做某种操作,不关心运行结果的情况。
2、Callable接口:继承Callable接口的类要实现它的call()方法,并将执行任务的代码放入其中,call()将任务的执行结果作为返回值。适合于执行某种操作后,需要知道执行结果的情况。
 
无论是接收Runnable型参数,还是接收Callable型参数的submit()方法,都会返回一个Future(也是一个接口)类型的对象。该对象中包含了任务的执行情况以及结果。调用Future的boolean isDone()方法可以获知任务是否执行完毕;调用Object get()方法可以获得任务执行后的返回结果,如果此时任务还没有执行完,get()方法会保持等待,直到相应的任务执行完毕后,才会将结果返回。
 
我们用下面的一个例子来演示Java5.0中线程池的使用:
Java代码
import java.util.concurrent.*;  
  
public class ExecutorTest {  
    public static void main(String[] args) throws InterruptedException,  
            ExecutionException {  
        ExecutorService es = Executors.newSingleThreadExecutor();  
        Future fr = es.submit(new RunnableTest());// 提交任务  
  
        Future fc = es.submit(new CallableTest());// 提交任务  
        // 取得返回值并输出  
        System.out.println((String) fc.get());  
  
        // 检查任务是否执行完毕  
        if (fr.isDone()) {  
            System.out.println("执行完毕-RunnableTest.run()");  
        } else {  
            System.out.println("未执行完-RunnableTest.run()");  
        }  
  
        // 检查任务是否执行完毕  
        if (fc.isDone()) {  
            System.out.println("执行完毕-CallableTest.run()");  
        } else {  
            System.out.println("未执行完-CallableTest.run()");  
        }  
  
        // 停止线程池服务  
        es.shutdown();  
    }  
}  
  
class RunnableTest implements Runnable {  
    public void run() {  
        System.out.println("已经执行-RunnableTest.run()");  
    }  
}  
  
class CallableTest implements Callable {  
    public Object call() {  
        System.out.println("已经执行-CallableTest.call()");  
        return "返回值-CallableTest.call()";  
    }  
}  
 
运行结果:
 
1、已经执行-RunnableTest.run()
2、已经执行-CallableTest.call()
3、返回值-CallableTest.call()
4、执行完毕-RunnableTest.run()
5、执行完毕-CallableTest.run()
 
使用完线程池之后,需要调用它的shutdown()方法停止服务,否则其中的所有线程都会保持运行,程序不会退出。