-
程序,进程,线程的概念
•程序(Program)是为实现特定目标或解决特定问题而用计算机语言(比如Java语言)编写的命令序列的集合。
这就是一个程序
•进程(process)指一个程序的一次执行过程。
public class Hello {
public static void main(String[] args) {
try {
Thread.sleep(10000); //调用sleep方法先使程序休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Hello World");
}
}
在这里,我们不直接执行输出语句,而是先使程序休眠,运行程序后我们打开任务管理器(快捷键ctrl+shift+esc),发现了该进程
•线程(thread)又称为轻量级进程,线程是一个程序中实现单一功能的一个指令序列,是一个程序的单个执行流,存在于进程中,是一个进程的一部分。
在刚刚的程序中任务管理器显示这个进程只有12个线程
public class Hello {
public static void main(String[] args) {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Hello World");
new Thread().start(); //启动线程
}
}
class TimeThread extends Thread{ //创建一个线程
@Override
public void run() { //重写线程运行方法
try {
Thread.sleep(5000); //先休眠五秒,确保我们在任务管理器中能看到线程数增加
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("111");
}
}
运行程序后我们查看任务管理器
此时尚未创建新的线程,线程数为14,10秒后
线程数增加1
-
如何创建线程对象
•第一种方式:继承java.lang.Thread类,重写run方法;
class 类名 extends Thread{
//属性
public void run(){
//线程需要执行的核心代码
}
//其他方法
}
public class Hello {
public static void main(String[] args) {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Hello World");
new TimeThread().start(); //直接通过TimeThread类创建对象调用
}
}
class TimeThread extends Thread{ //继承Thread类
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("111");
}
}
•第二种方式:实现java.lang.Runnable接口,实现run抽象方法。
class 类名 implements Runnable{
//属性
public void run(){
//线程需要执行的核心代码
}
//其他方法
}
public class Hello {
public static void main(String[] args) {
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Hello World");
new Thread(new TimeThread()).start(); //因为没有继承Thread类,所以需要使用Thread类名调用
}
}
class TimeThread implements Runnable{ //实现Runnable接口
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("111");
}
}
-
线程的生命周期
•新建状态(New):新创建了一个线程对象。
•就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
•运行状态(Running):就绪状态的线程获取了CPU使用权,执行程序代码。
•阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
1.等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。(wait会释放持有的锁)
2.同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。
3.其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。(注意,sleep是不会释放持有的锁);
•死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test{
public static void main(String[] args) {
new CountThread().start(); //启动线程
new Thread(new TimeThread()).start();//启动线程
}
}
class CountThread extends Thread{ //创建CountThread线程
@Override
public void run() {
for(int i=0;;i++) {
System.out.println("计数"+i);
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
class TimeThread implements Runnable{ //创建TimeThread线程
@Override
public void run() {
for (int i = 0;; i++) {
System.out.println("时间" + new Date());
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
运行程序时我们发现,两个线程并不是一个接一个执行,而是交替执行的
并且在执行的时候也没有先后顺序。
这是因为线程生命周期的特点,start方法启动了线程,但这不代表线程一定会运行,因为不同的线程之间通过抢占cpu的调用的方式来决定它们是否运行,在调用start方法后处于runnable状态待运行,并且进入线程池中开始抢占cpu使用权,等到抢占成功后便进入running状态开始运行,可能在一些情况下比如sleel方法使其休眠,会进入堵塞状态,此时cpu使用权被其他线程获取,其他线程进入running状态,该线程回归到runnable状态,直到出现异常或者线程完全执行完毕,进入dead状态结束其生命周期。
-
线程池
-
为什么要使用线程池
•提高程序的执行效率;
如果程序中有大量短时间任务的线程任务,由于创建和销毁线程需要和底层操作系统交互,大量时间都耗费在创建和销毁线程上,因而比较浪费时间,系统效率很低;线程池里的每一个线程任务结束后,并不会死亡,而是再次回到线程池中成为空闲状态,等待下一个对象来使用,因而借助线程池可以提高程序的执行效率。
•控制线程的数量,防止程序崩溃;
如果不加限制地创建和启动线程很容易造成程序崩溃,比如高并发1000W个线程,JVM就需要有保存1000W个线程的空间,这样极易出现内存溢出;线程池中线程数量是一定的,可以有效避免出现内存溢出。
-
如何使用线程池
•在JDK5之前,必须手动才能实现线程池,从JDK5开始新增了一个Executors工厂类,通过该工厂类可以实现线程池,该类有如下常用方法:
1.public static ExecutorService newCachedThreadPool():创建一个具有缓存功能的线程池,系统根据需要创建线程,这些线程将会被缓存在线程池中;
2.public static ExecutorService newFixedThreadPool(int nThreads):创建一个可重用的、具有固定线程数的线程池;
3.public static ExecutorService newSingleThreadExecutor():创建一个只有单线程的线程池,相当于调用newFixedThreadPool(int nThreads)方法时传入参数为1。
4.public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize):创建具有指定线程数的线程池,它可以在指定延迟后执行线程任务。 corePoolSize指池中所保存的线程数,即使线程时空闲的也被保存在线程池内。
5.public static ScheduledExecutorService newSingleThreadScheduledExecutor():创建只有一个线程的线程池,它可以在指定延迟后执行线程任务。
6.public static ExecutorService newWorkStealingPool(int parallelism):创建持有足够的线程的线程池来支持给定的并行级别,该方法还会使用多个队列来减少竞争。
public static ExecutorService newWorkStealingPool():该方法是前一个方法的简化版本。
如果当前机器有4个CPU,则目标并行级别被设置为4,也就是相当于为前一个方法传入4作为参数。
•ExecutorService 表示一个线程池,该接口常用方法:
1.Future<?> submit(Runnable task)
2.<T> Future<T> submit(Runnable task, T result)
3.void shutdown()
•步骤:
1.创建线程池对象;
2.创建Runable接口实现类实例;
3.提交Runable接口实现类实例;
关闭线程池