创建多线程的4种方式
1.线程是什么?
线程被称为轻量级进程,是程序执行的最小单位,它是指在程序执行过程中,能够执行代码的一个执行单位。每个程序都至少有一个线程,也即是程序本身。
2.线程状态
Java语言定义了5种线程状态,在任意一个时间点,一个线程有且只有其中一个状态。这5种状态如下:
(1)新建(New):创建后尚未启动的线程处于这种状态
(2)运行(Runable):Runable包括了操作系统线程状态的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间。
(3)等待(Wating):处于这种状态的线程不会被分配CPU执行时间。等待状态又分为无限期等待和有限期等待,处于无限期等待的线程需要被其他线程显示地唤醒,没有设置Timeout参数的Object.wait()、没有设置Timeout参数的Thread.join()方法都会使线程进入无限期等待状态;有限期等待状态无须等待被其他线程显示地唤醒,在一定时间之后它们会由系统自动唤醒,Thread.sleep()、设置了Timeout参数的Object.wait()、设置了Timeout参数的Thread.join()方法都会使线程进入有限期等待状态。
(4)阻塞(Blocked):线程被阻塞了,“阻塞状态”与”等待状态“的区别是:”阻塞状态“在等待着获取到一个排他锁,这个时间将在另外一个线程放弃这个锁的时候发生;而”等待状态“则是在等待一段时间或者唤醒动作的发生。在程序等待进入同步区域的时候,线程将进入这种状态。
(5)结束(Terminated):已终止线程的线程状态,线程已经结束执行。
下图是5种状态转换图:
3.线程同步方法
线程有4中同步方法,分别为wait()、sleep()、notify()和notifyAll()。
wait():使线程处于一种等待状态,释放所持有的对象锁。
sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用它时要捕获InterruptedException异常,不释放对象锁。
notify():唤醒一个正在等待状态的线程。注意调用此方法时,并不能确切知道唤醒的是哪一个等待状态的线程,是由JVM来决定唤醒哪个线程,不是由线程优先级决定的。
notifyAll():唤醒所有等待状态的线程,注意并不是给所有唤醒线程一个对象锁,而是让它们竞争。
4.创建线程的方式
在JDK1.5之前,创建线程就只有两种方式,即继承java.lang.Thread类和实现java.lang.Runnable接口;而在JDK1.5以后,增加了两个创建线程的方式,即实现java.util.concurrent.Callable接口和线程池。下面是这4种方式创建线程的代码实现。
4.1继承Thread类
1 //继承Thread类来创建线程 2 public class ThreadTest { 3 4 public static void main(String[] args) { 5 //设置线程名字 6 Thread.currentThread().setName("main thread"); 7 MyThread myThread = new MyThread(); 8 myThread.setName("子线程:"); 9 //开启线程 10 myThread.start(); 11 for(int i = 0;i<5;i++){ 12 System.out.println(Thread.currentThread().getName() + i); 13 } 14 } 15 } 16 17 class MyThread extends Thread{ 18 //重写run()方法 19 public void run(){ 20 for(int i = 0;i < 10; i++){ 21 System.out.println(Thread.currentThread().getName() + i); 22 } 23 } 24 }
4.2实现Runnable接口
1 //实现Runnable接口 2 public class RunnableTest { 3 4 public static void main(String[] args) { 5 //设置线程名字 6 Thread.currentThread().setName("main thread:"); 7 Thread thread = new Thread(new MyRunnable()); 8 thread.setName("子线程:"); 9 //开启线程 10 thread.start(); 11 for(int i = 0; i <5;i++){ 12 System.out.println(Thread.currentThread().getName() + i); 13 } 14 } 15 } 16 17 class MyRunnable implements Runnable { 18 19 @Override 20 public void run() { 21 for (int i = 0; i < 10; i++) { 22 System.out.println(Thread.currentThread().getName() + i); 23 } 24 } 25 }
4.3实现Callable接口
1 import java.util.concurrent.Callable; 2 import java.util.concurrent.ExecutionException; 3 import java.util.concurrent.FutureTask; 4 //实现Callable接口 5 public class CallableTest { 6 7 public static void main(String[] args) { 8 //执行Callable 方式,需要FutureTask 实现实现,用于接收运算结果 9 FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyCallable()); 10 new Thread(futureTask).start(); 11 //接收线程运算后的结果 12 try { 13 Integer sum = futureTask.get(); 14 System.out.println(sum); 15 } catch (InterruptedException e) { 16 e.printStackTrace(); 17 } catch (ExecutionException e) { 18 e.printStackTrace(); 19 } 20 } 21 } 22 23 class MyCallable implements Callable<Integer> { 24 25 @Override 26 public Integer call() throws Exception { 27 int sum = 0; 28 for (int i = 0; i < 100; i++) { 29 sum += i; 30 } 31 return sum; 32 } 33 }
相较于实现Runnable 接口的实现,方法可以有返回值,并且抛出异常。
4.4线程池
线程池提供了一个线程队列,队列中保存着所有等待状态的线程。避免了创建与销毁额外开销,提交了响应速度。
1 import java.util.concurrent.ExecutorService; 2 import java.util.concurrent.Executors; 3 //线程池实现 4 public class ThreadPoolExecutorTest { 5 6 public static void main(String[] args) { 7 //创建线程池 8 ExecutorService executorService = Executors.newFixedThreadPool(10); 9 ThreadPool threadPool = new ThreadPool(); 10 for(int i =0;i<5;i++){ 11 //为线程池分配任务 12 executorService.submit(threadPool); 13 } 14 //关闭线程池 15 executorService.shutdown(); 16 } 17 } 18 19 class ThreadPool implements Runnable { 20 21 @Override 22 public void run() { 23 for(int i = 0; i<10; i++){ 24 System.out.println(Thread.currentThread().getName() + ":" + i); 25 } 26 } 27 28 }