java多线程实现方式
继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。
其中前两种方式线程执行完后都没有返回值,后两种是带返回值的。
继承Thread类
继承Thread类的方法尽管被我列为一种多线程实现方式,但Thread本质上也是实现了Runnable接口的一个实例,它代表一个线程的实例,并且,启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法,它将启动一个新线程,并执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。例如:
public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}
启动线程
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
myThread1.start();
myThread2.start();
实现Runnable接口
如果自己的类已经extends另一个类,就无法直接extends Thread,此时,必须实现一个Runnable接口,如下:
public class MyThread extends OtherClass implements Runnable {
public void run() {
System.out.println("MyThread.run()");
}
}
为了启动MyThread,需要首先实例化一个Thread,并传入自己的MyThread实例:
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();
事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:
public void run() {
if (target != null) {
target.run();
}
}
使用ExecutorService、Callable、Future实现有返回结果的多线程
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591 ,这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征,确实很实用,有了这种特征我就不需要再为了得到返回值而大费周折了,而且即便实现了也可能漏洞百出。
可返回值的任务必须实现Callable接口,类似的,无返回值的任务必须Runnable接口。执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了,再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5下验证过没问题可以直接使用。代码如下:
import java.util.concurrent.*;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
/**
* 有返回值的线程
*/
@SuppressWarnings("unchecked")
public class Test {
public static void main(String[] args) throws ExecutionException,
InterruptedException {
System.out.println("----程序开始运行----");
Date date1 = new Date();
int taskSize = 5;
// 创建一个线程池
ExecutorService pool = Executors.newFixedThreadPool(taskSize);
// 创建多个有返回值的任务
List<Future> list = new ArrayList<Future>();
for (int i = 0; i < taskSize; i++) {
Callable c = new MyCallable(i + " ");
// 执行任务并获取Future对象
Future f = pool.submit(c);
// System.out.println(">>>" + f.get().toString());
list.add(f);
}
// 关闭线程池
pool.shutdown();
// 获取所有并发任务的运行结果
for (Future f : list) {
// 从Future对象上获取任务的返回值,并输出到控制台
System.out.println(">>>" + f.get().toString());
}
Date date2 = new Date();
System.out.println("----程序结束运行----,程序运行时间【"
+ (date2.getTime() - date1.getTime()) + "毫秒】");
}
}
class MyCallable implements Callable<Object> {
private String taskNum;
MyCallable(String taskNum) {
this.taskNum = taskNum;
}
public Object call() throws Exception {
System.out.println(">>>" + taskNum + "任务启动");
Date dateTmp1 = new Date();
Thread.sleep(1000);
Date dateTmp2 = new Date();
long time = dateTmp2.getTime() - dateTmp1.getTime();
System.out.println(">>>" + taskNum + "任务终止");
return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";
}
}
上述代码中Executors类,提供了一系列工厂方法用于创先线程池,返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。
ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。
线程状态
状态图:
-
新建状态(NEW):当线程对象被创建后,就进入了新建状态。例如,当使用new关键字创建一个线程时,该线程就处于新建状态。
-
就绪状态(Runnable):也被称为“可执行状态”。当线程对象被创建后,如果其他线程(比如main线程)调用了该对象的start()方法,就会启动该线程,使其进入就绪状态。处于就绪状态的线程随时可能被CPU调度执行。
-
运行状态(Running):线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态。
-
阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分为三种:
- 等待阻塞:运行(running)的线程执行o.wait()方法,JVM会把该线程放入等待队列(waitting queue)中。让线程等待某工作的完成。
- 同步阻塞:线程在获取synchronized同步锁失败,锁被其它线程所占用,则JVM会把该线程放入锁池(lock pool)中,它会进入同步阻塞状态。
- 其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
-
死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。死亡的线程不可再次复生。
死亡状态
进入的条件:
- run方法正常退出而自然死亡,
- 一个未捕获的异常终止了run方法而使线程猝死。
- 或者主线程的main()方法完成时,我们就认为它死去。
说明:
- 在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。
- 使用isAlive方法。如果是可运行或被阻塞,这个方法返回true; 如果线程仍旧是new状态且不是可运行的, 或者线程死亡了,则返回false.
线程方法
sleep()
, yield()
, wait()
, notify()
, join()
和 interrupt()
这些方法都是用于线程控制的常用方法。
1.Thread.sleep(long millis)
当前线程调用此方法,当前线程进入阻塞,但不释放对象锁,而是会进入休眠状态,暂时停止执行。在休眠期间,该线程不会释放锁,其他线程也无法进入。millis后线程自动苏醒会重新进入就绪状态,等待CPU调度。
作用:
- 延迟执行:通过指定一段时间的睡眠,可以让线程暂停执行一段时间后再继续执行,用于实现定时操作或者按照规定时间间隔执行某些任务。
- 控制并发:在多线程编程中,当对共享资源进行操作时,可能会发生竞争条件。使用Thread.sleep()方法可以避免这种情况,因为它可以让当前线程暂停执行一段时间,以便其他线程有机会获取共享资源。
- 减少CPU使用率:通过使用Thread.sleep()方法,可以让线程暂停执行一段时间,从而减少CPU的使用率。这对于节能和性能优化非常有用。
2.Thread.yield()
当前线程调用此方法,当前线程放弃获取的cpu时间片,由运行状态变会就绪状态,让OS再次选择线程。相同优先级的线程轮流执行,它并不能保证其他线程一定会获得执行权。因为其他线程是否能够获得执行权取决于它们的优先级、CPU调度等具体情况。因此,即使调用了Thread.yield()方法,其他线程也不一定会进入该线程的代码块。Thread.yield()不会导致阻塞。
作用:
- 减少CPU使用率:通过使用Thread.yield()方法,可以让线程暂停执行一段时间,从而减少CPU的使用率。这对于节能和性能优化非常有用。
- 控制并发:在多线程编程中,当对共享资源进行操作时,可能会发生竞争条件。使用Thread.yield()方法可以避免这种情况,因为它可以让当前线程暂停执行一段时间,以便其他线程有机会获取共享资源。
3.t.join()/t.join(long millis)
当前线程里调用其它线程t的join方法,当前线程阻塞,但不释放对象锁,直到线程t执行完毕或者millis时间到,当前线程进入可运行状态。
t.join()
和 t.join(long millis)
是 Java 中 Thread 类的方法,用于等待线程 t
终止。
两者的区别在于:
t.join()
:这个方法将调用线程置为阻塞状态,直到对应的线程终止。这种方法通常在主线程中使用,等待其他线程执行完毕。如果对应的线程已经终止,则立即返回。t.join(long millis)
:这个方法也是等待线程t
终止,但是等待的时间是millis
毫秒。如果在指定的时间内线程t
没有终止,那么这个方法会返回。需要注意的是,如果millis
的值是零或者负数,那么这个方法会立即返回。
class MyThread extends Thread {
public void run() {
// 模拟一个耗时操作
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Main {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start(); // 启动线程 t
try {
t.join(); // 主线程等待 t 结束
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t has finished execution.");
}
}
在这个例子中,MyThread
类继承了 Thread
类并重写了 run
方法。在 run
方法中,我们使用 Thread.sleep(3000)
来模拟一个耗时操作。在主类 Main
中,我们首先启动了线程 t
,然后使用 t.join()
来等待线程 t
结束。当线程 t
结束后,t.join()
才会返回,然后打印出 "t has finished execution."。
4.obj.wait()
当一个线程调用一个对象的 wait()
方法时,它会进入等待状态,直到其他线程调用同一个对象的 notify()
或 notifyAll()
方法来唤醒它或者wait(long timeout)timeout时间到自动唤醒。
使用 obj.wait()
方法时需要注意以下几点:
wait()
方法必须在同步块或同步方法中调用,否则会抛出IllegalMonitorStateException
异常。这是因为wait()
方法需要获取对象的锁。wait()
方法会释放对象的锁,以便其他线程可以获取该锁并进行操作。这是wait()
方法与synchronized
关键字配合使用时的重要特性,也是实现多线程协作的一种常见方式。wait()
方法需要与notify()
或notifyAll()
方法配合使用,否则会造成死锁。wait()
方法可能会被打断,如果当前线程在等待时被其他线程中断,它会抛出InterruptedException
异常。
总之,obj.wait()
方法是一种用于线程之间协作的机制,可以让一个线程等待另一个线程的操作完成或状态变化。它在生产者-消费者模式中非常常见,可以帮助我们实现更高效的多线程程序。
5.obj.notify()
obj.notify()
是 Java 的 Object
类中的一个方法,用于唤醒等待同一个对象的一个线程。如果有多个线程在等待同一个对象,obj.notify()
只会唤醒其中一个线程。具体唤醒哪个线程是由 Java 虚拟机实现决定的,开发人员无法控制。
关于是否释放锁,与 obj.wait()
一样,obj.notify()
也会释放对象的锁。被唤醒的线程会获取对象的锁,然后继续执行。
使用场景方面,obj.notify()
或 obj.notifyAll()
常用于生产者-消费者模式中。当缓冲区有数据时,消费者线程会等待获取数据。当缓冲区没有数据时,生产者线程可以生产数据并调用 obj.notify()
来唤醒等待的消费者线程。这样,消费者线程可以继续获取并处理数据,生产者线程也可以继续生产数据,实现了多线程的协作。
需要注意的是,obj.notify()
或 obj.notifyAll()
必须与 synchronized
关键字配合使用,否则会抛出 IllegalMonitorStateException
异常。同时,被唤醒的线程不一定是按照先后顺序执行的,因此需要注意多线程并发控制的问题。
常见问题
1、造成线程阻塞的方法
阻塞线程的方法:join、yield、sleep 和Object的wait()方法
2、Java的守护进程(后台进程)
设置线程为后台进程运行:setDaemon(true) 如果一个进程中只有后台线程在运行,这个进程就会结束。
3、造成线程阻塞后,线程回到哪个状态了
通过join、yield、sleep造成线程阻塞后是回到了就绪状态
3、哪些状态之后是回到就绪状态
a)通过join、yield、sleep造成线程阻塞后是回到了就绪状态
b)遇到synchronized后
c)遇到Object的等待wait方法后
4、sleep会释放锁吗
sleep不会释放锁【它会抱着锁睡觉】
5、终止线程有哪几种方法
线程调用 stop()方法、destory()方法或 run()方法执行结束后,线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。
6、创建线程的开销
线程的创建需要消耗一定的系统资源,包括内存空间、CPU时间等。在创建一个新线程时,操作系统需要为该线程分配独立的内存空间,这个过程需要消耗一定的内存资源。同时,线程的创建和管理也需要消耗CPU的时间,包括线程的调度、上下文切换等。
在并发量大的情况下,频繁地创建和销毁线程会对系统资源造成额外的消耗,可能会引发系统资源耗尽的风险。因此,很多系统采用线程池技术来限制线程的随意创建,提高资源复用,降低系统的开销。
另外,线程的创建也与程序的具体实现有关,如果程序中有死循环等无限循环的情况,可能会导致线程无法正常结束,从而一直占用系统资源。因此,在编写多线程程序时需要注意资源的合理分配和管理,避免出现死循环等异常情况。