-
程序，进程，线程的概念
•程序(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接口实现类实例；
关闭线程池