多线程相关的三组概念
程序和进程
-
程序（program）：一个固定的运行逻辑和数据的集合，是一个静态的状态，一般存储在硬盘中。简单来说就是我们编写的代码
-
进程（process）：一个正在运行的程序，一个程序的一次运行，是一个动态的概念般存储在内存中。 例如：command + option + esc，打开任务管理器可以看到所有进程
-
进程是正在运行的一个程序：
程序是静态的：QQ这个程序，如果不运行就是存在磁盘中，不占内存，所以是静态的。
进程是动态的：QQ这个程序，如果在运行就运行在内存中，占用内存，所以是动态的。
进程和线程
-
进程（process）：一个正在运行的程序，一个程序的一次运行，是一个动态的概念存储在内存中。
-
比如我们使用QQ,就启动了一个进程，操作系统就会为该进程分配内存空间，比如我们再启动迅雷，就会又启动一个进程，操作系统会给迅雷分配新的内存空间
-
进程是程序的一次执行过程，或是正在运行的一个程序，是一个动态的过程，有它自身的产生，存在和消亡的过程
-
-
线程（thread）：一条独立的执行路径。多线程，在执行某个程序的时候，该程序可以有多个子任务，每个线程都可以独立的完成其中一个任务。在各个子任务之间，没有什么依赖关系，可以单独执行。
-
线程是由进程创建的，是进程的一个实体
-
一个进程可以拥有多个线程
-
-
进程和线程的关系： 进程是用于分配资源的单位 一个进程中，可以有多条线程；但是一个进程中，至少有一条线程
比如当我们启动迅雷时，就开启一个进程，使用迅雷时我们可以同时下载5个电影资源，每一个下载任务就是一个线程
线程不会独立的分配资源，一个进程中的所有线程，共享同一个进程中的资源
并行和并发
-
并行（parallel）：多个任务（进程、线程）同时运行。在某个确定的时刻，有多个任务在执行，多个cpu可以实现并行。 条件：有多个cpu，多核编程
-
并发（concurrent）：多个任务（进程、线程）同时发起。不能同时执行的（只有一个cpu），只能是同时要求执行。就只能在某个时间片内，将多个任务都有过执行。一个cpu在不同的任务之间，来回切换，只不过每个任务耗费的时间比较短，cpu的切换速度比较快，所以可以让用户感觉就像多个任务在同时执行。并发就是同一时刻，多个任务交替执行，造成一种，“貌似同时”的错觉，简单来说，单核cpu实现的多任务就是并发
-
举例：
-
并发
2.并行
-
一个人可以同时做多件事儿，就是并发
多个人可以同时做多件事儿，就是并行
并发是多个任务之间互相抢占资源
并行是多个任务之间不互相抢占资源
并发的关键是你有处理多个任务的能力，不一定要同时。 并行的关键是你有同时处理多个任务的能力。
最关键的点就是：是否是『同时』。
但是我们的电脑也会存在并发与并行同时存在的情况
并行和并发的图示
并发的本质：不同任务来回切换：
并行和并发的比较：
问&答：
问：既然只有一个cpu，还需要在不同的任务之间来回切换，那么效率到底是提升了还是降低了？
答：
1、提升了：整个系统的效率提升了（cpu的使用率提升了），对于某个具体的任务而言，效率是降低了
2、并发技术，解决的是不同的设备之间速率不同的问题 cpu： 10^-9秒 大概是千分之一毫秒 执行一次. 0.000000001 内存：10^-6秒 0.000001 磁盘：10^-3秒 0.001 人：10^0秒.
3、cpu 的效率非常高，给磁盘一个指令，让磁盘寻找某个字节，cpu就赶紧切换到其它的任务，执行其它的
计算、存储的操作。这样子就可以让计算机系统中的所有设备都运转起来，提升了cpu的使用率。绝不能出现
cpu这种昂贵的设备等待磁盘这种廉价设备的情况。
多线程的实现方式
多线程实现方式一：继承方式
-
继承Thread
-
步骤：
1、定义一个类，继承Thread类
2、重写自定义类中的run方法，用于定义新线程要运行的内容
3、创建自定义类型的对象
4、调用线程启动的方法：start()方法
代码示例：
/**
* 多线程实现方式一：实现方式
*/
public class Simple01 {
public static void main(String[] args) {
// 创建自定义类型的对象
MyThread mt = new MyThread();
// 调用对象的start方法，启动线程
mt.start(); // 用主线程 调用自定义的线程
// 让主线程（主方法本来就所在的线程）继续运行
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
// 现象是主线程内容和新线程内容交替执行，两条线程相互没有依赖关系
}
}
// 定义一个类，继承Thread类
class MyThread extends Thread {
//重写run方法，定义线程的运行内容
@Override
public void run() {
for (int i = 0; i <=100; i++) {
System.err.println(i);
}
}
}多线程实现方式二：实现方式
-
实现Runnable接口：
Runnable接口的实现类对象，表示一个具体的任务，将来创建一个线程对象之后，让线程执行这个任务
-
步骤： 1、定义一个任务类，实现Runnable接口 2、重写任务类中的run方法，用于定义任务的内容 3、创建任务类对象，表示任务 4、创建一个Thread类型的对象，用于执行任务类对象 5、调用线程对象的start方法，开启新线程
代码示例：
/**
* 多线程实现方式二：实现方式
*/
public class Simple02 {
public static void main(String[] args) {
// 创建任务类对象
MyTask myTask = new MyTask();
// 创建线程对象，绑定要执行的任务
Thread thread = new Thread(myTask);
// 启动新线程
thread.start();
for (int i = 1; i <= 10000; i++) {
System.out.println(i);
}
}
}
// 定义一个任务类
class MyTask implements Runnable{
@Override
// 重写run方法，定义任务的内容
public void run() {
for (int i = 1; i <= 10000; i++) {
System.err.println(i);
}
}
}两种方式的比较
-
代码复杂程度：
继承Thread方式简单
实现Runnable接口的方式比较复杂
-
设计：java中只支持单继承、不支持多继承
-
继承方式：
某个类继承了Thread类，那么就无法继承其他业务中需要的类型，就限制了我们的设计。所以扩展性较差。
-
实现方式：
某个类通过实现Runnable的方式完成了多线程的设计，仍然可以继承当前业务中的其它类型，扩展性较强。
-
-
灵活性：
-
继承方式：
将线程对象和任务内容绑定在了一起，耦合性较强、灵活性较差
-
实现方式：
将线程对象和任务对象分离，耦合性就降低，灵活性增强：同一个任务可以被多个线程对象执行，某个线程对象也可以执行其它的任务对象。并且将来还可以将任务类对象，提交到线程池中运行；任务类对象可以被不同线程运行，方便进行线程之间的数据交互。
-
使用匿名内部类创建线程对象
代码示例：
/**
* 使用匿名内部类创建线程对象
*/
public class Simple03 {
public static void main(String[] args) {
//第一条线程打印1-100，使用继承的方式
new Thread() {
@Override
public void run() {
for(int i = 1; i <= 100; i++) {
System.out.println(i + "...extends");
}
}
}.start();
//第二条线程打印1-100，使用实现的方式
new Thread(new Runnable() {
@Override
public void run() {
for(int i = 1; i <= 100; i++) {
System.out.println(i + "...implements" );
}
}
}).start();
}
}Thread类中的常用方法
获取线程名称
-
getName()：获取线程的名称
-
注意事项： 1、如果没有给线程命名，那么线程的默认名字就是Thread-x，x是序号，从0开始
代码示例：
/**
* 获取线程名称
*/
public class Simple04 {
public static void main(String[] args) {
Thread thread = new Thread() {
@Override
// 继承方式 可以加this关键字找到getName
public void run() {
System.out.println("name:"+this.getName() );
}
};
thread.setName("线程0");
thread.start();
Thread thread1 = new Thread() {
@Override
public void run() {
System.out.println("name1:"+this.getName() );
}
};
thread1.setName("线程1");
thread1.start();
}
}设置线程名称
-
setName(String name) 使用线程对象的引用，调用该方法给线程起名字
-
构造方法： Thread(String name)：给线程通过构造方法起名字 Thread(Runnable target, String name)：在给线程target对象赋值的同时，也给线程起名
-
注意事项： 线程设置名字，既可以在启动之前设置，也可以在启动之后设置
代码名称：
/**
* 设置 线程名称
*/
public class Simple05 {
public static void main(String[] args) {
Thread thread = new Thread("线程0") {
@Override
// 继承方式 可以加this关键字找到getName
public void run() {
System.out.println("name:"+this.getName() );
}
};
thread.start();
new Thread(new Task(),"线程1") {
@Override
public void run() {
System.out.println("name:"+this.getName() );
}
}.start();
}
}
class Task implements Runnable{
@Override
public void run() {
}
}获取当前线程对象
1、作用： 某段代码只要是在执行，就一定是在某个方法中执行的，只要在某个方法中，代码就一定是被某个线程执行的。所以任意一句代码，都有执行这句代码的线程对象。 可以在任意位置，获取当前正在执行这段代码的线程对象 2、方法： Thread Thread.currentThread(); 返回当前正在执行这段代码的线程对象的引用 哪条线程在执行这段代码，返回的就是哪条线程
代码示例：
/**
* 获取当前线程对象
*/
public class Simple06 {
public static void main(String[] args) {
Thread thread = new Thread("线程0") {
@Override
// 继承方式 可以加this关键字找到getName
public void run() {
System.out.println("name:"+this.getName() );
}
};
thread.start();
// System.out.println(thread.getName());
new Thread(new Task(),"线程1").start();
}
}
class Task implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread());
}
}线程休眠
-
Thread.sleep(long time) 让当前线程休眠 time：休眠的时间，单位是毫秒
-
作用： 当某段代码在某个位置需要休息的时候，就使用线程的休眠 无论哪个线程在运行这段代码，碰到sleep方法都需要停下休息
-
注意事项： 有一个异常，中断异常：InterruptedException 在普通方法中，可以声明抛出 在重写的run方法中，必须只能处理，不能声明
代码示例：
/** * 线程休眠 */ public class Simple07 { public static void main(String[] args) throws InterruptedException { // InterruptedException 中断异常 // System.out.println(1); // Thread.sleep(1000); // System.out.println(2); MyCountDown myCountDown = new MyCountDown(); Thread thread = new Thread(myCountDown); thread.start(); } } class MyCountDown implements Runnable { @Override public void run() { // 在run方法中，异常只能处理，不能抛出 for (int i = 5; i >= 1; i--) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(i); } } }
守护线程
-
setDaemon(boolean flag)：每条线程默认不是守护线程，只有设定了flag为true之后，该线程才变成守护线程
-
isDaemon()：判断某条线程是否是守护线程
-
守护线程的特点： 守护线程就是用于守护其它线程可以正常运行的线程，在为其它的核心线程准备良好的运行环境。
如果非守护线程全部死亡，守护线程就没有存在的意义了，一段时间之后，虚拟机也一同结束。
虚拟机结束了，所有线程都结束了。
-
别名： 后台线程
好比前台的表演都是需要后台工作人员的准备支持，前台没有人表演了，那么后台工作人员就没有存在的意义了。
在jvm中，gc就是守护线程，作用就是当用户自定义的线程以及主线程执行完毕后，gc才停止工作，
不然的话，当主线程没有执行结束，gc就结束了，这样就会造成gc垃圾还没有清理完，主线程早就挂了。
(注意：主线程不是守护线程，gc才是守护线程)。
我们只需要了解什么是守护线程的概念，即可。
代码示例：
/**
* 线程守护
*/
public class Simple08 {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
for (int i = 0; i < 100; i++) {
System.out.println(i+"...守护线程");
}
});
// 设置为守护线程
thread.setDaemon(true);
System.out.println(thread.isDaemon());
// 启动之后，系统中就有两条线程：主线程和守护线程
thread.start();
for (int i = 1; i <= 50; i++) {
System.out.println(i + "...main");
}
//主线程运行完成之后，系统中就只剩下了守护线程
//如果非守护线程全部死亡，守护线程就没有存在的意义了，
//一段时间后，虚拟机也一同结束。
//当主线程执行结束，jvm还没有立即结束，所以守护线程还会执行一段时间
}
}在实际开发中，守护线程（Daemon Thread）有以下主要作用：
-
后台任务执行：守护线程通常用于执行后台任务，这些任务不需要对用户可见，且不影响主线程的执行。比如，在 Web 服务器中，可以使用守护线程处理一些定时任务、日志记录等后台操作，而不会影响用户请求的处理。
-
资源回收：守护线程在 JVM 关闭时会自动终止，并且它们的执行不会阻止 JVM 退出。因此，守护线程通常用于执行资源回收工作，如垃圾回收器（Garbage Collector）线程就是守护线程，负责回收不再使用的对象。
-
定时任务：守护线程可以用于执行定时任务，如定时更新缓存、定时发送心跳包等。这样可以在后台自动执行这些任务，而不需要手动触发。
-
后台服务：某些后台服务可能需要一直运行，并随着应用的启动而启动。这些服务可以作为守护线程运行，以确保在应用退出时能够自动终止。
多线程中的线程安全问题
问题描述
某段代码在没有执行完成的时候，cpu就可能被其它线程抢走，结果导致当前代码中的一些数据发生错误
原因：没有保证某段代码的执行的完整性、原子性
希望：这段代码要么全都执行，要么全都没有执行
代码示例：
/**
* 多线程中的线程安全问题
* 模拟出票系统
*/
public class Simple01 {
public static void main(String[] args) {
Ticket ticket = new Ticket(); // 堆中只有一个对象
Thread thread1 = new Thread(ticket, "窗口1");
Thread thread2 = new Thread(ticket, "窗口2");
Thread thread3 = new Thread(ticket, "窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
class Ticket implements Runnable {
private int ticktNum = 0;//票号
// 线程售票
public void run() {
while (ticktNum < 10) { // 模拟售10张票
// 1.模拟出票时间
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 2.打印进程号和票号
String name = Thread.currentThread().getName();
ticktNum = ++ticktNum;
System.out.println("线程" + name + "售票：票号" + ticktNum);
}
// 出现的问题，某票号有可能被卖了多次
// 不存在的票10号也有可能出现出现了
// 出现不存在的票号原因：线程1，2在tickNum++ 时候被其他线程抢走了。倒置被累加多次
}
}多个线程对全局变量只读，不写，那么一般这个变量是安全的，
多个线程同时执行写的操作，那么就需要考虑线程同步的问题，否则会影响线程安全问题
综上所述，线程安全问题根本原因：
-
多个线程在操作共享的数据；
-
多个线程对共享数据有写的操作；
问题解决：
要解决以上线程问题，只要在某个线程修改共享资源的时候，其它线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。
为了保证每个线程都能正常执行共享资源操作,Java引入了线程同步机制：
构造代码块
1) 同步代码块（synchronized）
2) 同步方法 （synchronized）
同步代码块
-
同步代码块： 使用一种格式，达到让某段代码执行的时候，cpu不要切换到影响当前代码的代码上去 这种格式，可以确保cpu在执行A线程的时候，不会切换到其它线程上去
-
使用格式 synchronized (锁对象) { 需要保证完整性、原子性的一段代码（需要同步的代码） }
-
使用同步代码块之后的效果： 当cpu想去执行同步代码块的时候，需要先获取到锁对象，获取之后就可以运行代码块中的内容；
当cpu正在执行当前代码块内容时，cpu可以切换到其它代码，但是不能切换到具有相同锁对象上；
当cpu执行完当前代码块中代码之后, 会释放锁对象，cpu就可以运行其它具有当前锁对象的同步代码块了；
代码示例：
/**
* 同步代码块
*/
public class Simple02 {
public static void main(String[] args) {
Printer p = new Printer();
Thread t1 = new Thread() {
@Override
public void run() {
while (true) {
p.print1();
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
while (true) {
p.print2();
}
}
};
t1.start();
t2.start();
}
}
class Printer {
Object object = new Object();
public void print1() {
// 线程1在获取了obj锁之后，线程2就无法获取obj锁，
// 就只能等待线程1运行完这个方法，两条线程才能再次共同争夺锁对象
synchronized (object) {
System.out.print("码");
System.out.print("上");
System.out.print("未");
System.out.println("来");
}
}
public void print2() {
synchronized (object) {
System.err.print("线");
System.err.print("程");
System.err.println("锁");
}
}
}
// 不加锁的话，会出现：码上未来码 线程锁码 等数据不准确现象
// A线程执行print1完毕 释放obj对象，然后cpu被B线程抢去执行print2方法，
// B线程执行print2完毕，释放obj对象，然后cpu又被A或者B 线程抢去执行对应方法，同步方法
1、同步代码块：在某段代码执行的时候，不希望cpu切换到其他影响当前线程的线程上去，就在这段代码上加上同步代码块，至于该方法中一些只读的成员变量就不需要放在同步代码块中了。
所以同步代码块中，只存放需要保证完整性、原子性的一段代码。
2、如果某个方法中，所有的代码都需要加上同步代码块，使用同步方法这种【简写格式】来替代同步代码块
3、同步方法的格式：
权限修饰符 [静态修饰符] synchronized 返回值类型 方法名称(参数列表) {
需要同步的方法体
}
4、同步方法的锁对象
如果是非静态的方法，同步方法的锁对象就是this，当前对象，哪个对象调用这个同步方法，这个同步方法使用的锁就是哪个对象
5、如果是静态的方法，同步方法的锁对象就是当前类的字节码对象，类名.class（在方法区的一个对象），哪个类在调用这个同步方法，这个同步方法使用的锁就是哪个类的字节码对象
代码示例：
/**
* 同步方法
*/
public class Simple03 {
public static void main(String[] args) {
Printer p = new Printer();
Thread t1 = new Thread() {
@Override
public void run() {
while (true) {
p.print1();
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
while (true) {
p.print2();
}
}
};
t1.start();
t2.start();
}
}
class Printer {
public static synchronized void print1() {
System.out.print("码");
System.out.print("上");
System.out.print("未");
System.out.println("来");
}
public static synchronized void print2() {
System.err.print("线");
System.err.print("程");
System.err.println("锁");
}
}6、特别注意，如果是静态方法，在静态方法内部使用同步代码块，同步代码块锁对象也是当前类的字节码对象
/**
* 静态方法中使用同步代码块
*/
public class Simple04 {
public static void main(String[] args) {
Printer p = new Printer();
Thread t1 = new Thread() {
@Override
public void run() {
while (true) {
p.print1();
}
}
};
Thread t2 = new Thread() {
@Override
public void run() {
while (true) {
p.print2();
}
}
};
t1.start();
t2.start();
}
}
class Printer {
public static void print1() {
synchronized (Printer.class) {
System.out.print("码");
System.out.print("上");
System.out.print("未");
System.out.println("来");
}
}
public static void print2() {
synchronized (Printer.class) {
System.err.print("线");
System.err.print("程");
System.err.println("锁");
}
}
}锁对象的说明
-
线程加上同步是为了让两条线程相互不要影响，如果相互影响，影响的是数据的正确性
-
使用锁对象，其实主要是为了锁数据。当某条线程在操作这个数据时，其它线程不能操作当前的数据。
-
如果两条线程要操作相同的数据，那么这两条线程就需要在操作数据的部分都加上同步代码块，并且使用相同的锁对象。
死锁
-
A线程需要甲资源，同时拥有乙资源；B线程需要乙资源，同时拥有甲资源，两条线程都不肯释放自己拥有的资源，同时也需要其它的资源时，就都无法进行运行。形成“死锁”现象。
-
代码表现： 有了同步代码块的嵌套，就可能发生死锁。某条线程获取了外层锁对象A，需要内层锁对象B，等待；
因为另一条线程此时已经获取了外层的锁对象B，需要内层的锁对象A，等待。两条线程就会形成死锁。
代码示例：
/**
* 死锁
*/
public class Simple05 {
public static void main(String[] args) {
Thread t1 = new Thread("苏格拉底") {
public void run() {
while (true) {
synchronized ("筷子A") {
System.out.println("苏格拉底争取到了筷子A，等待筷子B");
synchronized ("筷子B") {
System.out.println("苏格拉底获取了所有的筷子，狂吃狂吃");
}
}
}
}
};
Thread t2 = new Thread("柏拉图") {
public void run() {
while (true) {
synchronized ("筷子B") {
System.out.println("柏拉图争取到了筷子B，等待筷子A");
synchronized ("筷子A") {
System.out.println("柏拉图获取了所有的筷子，狂吃狂吃");
}
}
}
}
};
t1.start();
t2.start();
}
}
// 开发尽量避免锁的嵌套以此 来避免死锁现象发生。
// 公平锁 非公平锁 表锁 行锁 自旋锁火车票案例
/**
* 火车票案例
*/
public class Simple06 {
/**
* 三个窗口，同时售卖100张火车票
* 打印某个窗口卖出了1张票，还剩x张
* 窗口是随机的
*
* @param args
*/
public static void main(String[] args) {
Tickets t1 = new Tickets();
Tickets t2 = new Tickets();
Tickets t3 = new Tickets();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Tickets extends Thread {
//为了让多个线程多个对象 共享同一个数据 我们加上静态
private static int tickets = 100;
public void run() {
while (true) {
// 多个线程 使用同一个锁对象 使用xx.class
synchronized (Tickets.class) {
if (tickets <= 0) {
break;
}
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
//线程1等待 线程2等待
//线程3 把ticket-- 变成0 这时候cpu切换到线程1 线程1执行--操作变为-1
tickets--;
System.out.println(getName() + "卖出了1张票， 还剩" + tickets + "张票");
}
}
}
}线程生命周期
概述
-
线程是一个动态的概念，有创建的时候，也有运行和变化的时候，必须也就有消亡的时候，所以从生到死就是一个生命周期。在生命周期中，有各种各样的状态，这些状态可以相互转换。
-
状态罗列： 新建态：刚创建好对象的时候，刚new出来的时候 就绪态：线程准备好了所有运行的资源，只差cpu来临 运行态：cpu正在执行的线程的状态 阻塞态：线程主动休息、或者缺少一些运行的IO资源，即使cpu来临，也无法运行 死亡态：线程运行完成、出现异常、调用方法结束
状态转换图
Java中线程状态的描述
-
线程状态只是理论上的状态，在计算机系统中有更加精确的描述，可以将各种不同的状态，封装成对象，这些对象可能和理论状态不完全相同。
-
Java语言中，获取线程状态的方法： getState()：返回当前线程对象的状态对象；返回值类型是Thread.State，Thread的内部类
-
Thread.State：Java语言中，描述线程状态的类型 说明：由于状态时有限个的，所以该类的对象，不需要手动创建，直接在类中创建好了，获取即可，
这种类型就是枚举类型。每个对象，称为枚举项。
Thread.State中，枚举项：6个 NEW：新建态，没有开启线程 RUNNABLE：就绪态和运行态 BLOCKED：阻塞态 （等待锁、I\O，等待锁对象释放了，IO资源准备完毕了，就不阻塞了） WAITING：阻塞态 （调用了wait方法，等待其它线程唤醒的状态，没人喊它，它就一直阻塞） TIMED_WAITING：阻塞态（调用了有时间限制的wait方法、sleep方法） TERMINATED：死亡态
代码示例：
public class Simple01 {
public static void main(String[] args) throws InterruptedException {
//test1_new_timedWaiting_terminated_runnable();
test2_blocked_TERMINATED();
}
//演示blocked阻塞状态
public static void test2_blocked_TERMINATED() throws InterruptedException {
Thread t1 = new Thread("t1线程") {
public void run() {
synchronized ("abc") {
for (int i = 0; i <= 3; i++) {
//打印数字，和线程名称
System.out.println(i + "..." + getName());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
Thread t2 = new Thread("t2线程") {
public void run() {
//没有获取到锁的线程对象的状态是：BLOCKED
synchronized ("abc") {
for (int i = 0; i <= 3; i++) {
System.out.println(i + "..." + getName());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
t1.start();
t2.start();
while (true) {
System.out.println("t1...." + t1.getState());
System.out.println("t2...." + t2.getState());
Thread.sleep(50);
//t1 和 t2 判断线程是否结束
if (t1.getState().equals(Thread.State.TERMINATED) &&
t2.getState().equals(Thread.State.TERMINATED)) {
System.out.println("两条线程都结束了");
break;
}
}
}
private static void test1_new_timedWaiting_runnable() throws InterruptedException {
Thread t1 = new Thread() {
public void run() {
for (int i = 1; i < 100; i++) {
System.out.println(i);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
System.out.println("A:" + t1.getState());//NEW
t1.start();
System.out.println("B:" + t1.getState());//RUNNABLE
Thread.sleep(10);//0.01
System.out.println("C:" + t1.getState());//TIMED_WAITING
}
}线程池
概述
-
没有线程池的状态：
当使用一条线程的时候，先将线程对象创建出来，启动线程，在运行过程中，正常完成任务之后，线程对象就结束了，就变成了垃圾对象，需要被垃圾回收器回收如果在系统中，大量的任务都是小任务，任务消耗时间较短、线程对象的创建和消亡耗费的时间比较多，
结果：大部分的时间都浪费在了线程对象的创建和死亡上。
-
有线程池的状态 在没有任务的时候，先把线程对象准备好，存储到一个容器中，一旦有任务来的时候，就不需要创建
对象，而是直接将对象获取出来执行任务如果任务破坏力较小，任务可以直接完成，这个线程对象不
会进入死亡状态，而是被容器回收，继续活跃。如果任务破坏力较大，把线程任务搞死了，那么线程池
也会继续提供下一个线程，继续完成这个任务。
线程池使用
-
步骤：获取线程池对象；创建任务类对象；将任务类对象提交到线程池中
-
获取线程池对象：
工具类：
//Executors：生成线程池的工具类，根据需求生成指定大小的线程池 //ExecutorService Executors.newSingleThreadExecutor()：创建一个有单个线程的线程池 //ExecutorService Executors.newFixedThreadPool(int nThreads)：创建一个指定线程数量的线程池 -
创建任务类对象：Runnable的实现类对象，用于定义任务内容
-
将任务类对象提交到线程池中 ExecutorService：是一个接口，不需要手动创建这个接口的实现类对象，使用方法获取到的就是这个接口的实现类对象，就可以调用这个接口中的方法
-
submit(Runnable r)：可以将一个任务类对象，提交到线程池中，如果有空闲的线程，就可以马上运行这个任务，如果没有空闲线程，那么这个任务就需要等待。
-
shutDown()：结束线程池，已经提交的全部保证完成，在此代码后就不准继续提交任务了
-
shutDownNow()：结束线程池，已经开始运行的，保证完成，等待的任务不保证完成
但是已经提交的，还没有运行的，就不给运行了，作为返回值范围；对于没有提交的，不准提交。
代码示例：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Simple02 {
public static void main(String[] args) {
// 准备一个线程池对象 1个
// ExecutorService es = Executors.newSingleThreadExecutor();
// 准备一个线程池对象 2个
ExecutorService es = Executors.newFixedThreadPool(2);
Object obj = new Object();
Runnable r1 = new Runnable() {
@Override
public void run() {
synchronized (obj) {
for (int i = 1; i <= 10; i++) {
System.out.println(i + "..." + Thread.currentThread().getName());
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
Runnable r2 = new Runnable() {
@Override
public void run() {
synchronized (obj) {
for (int i = 11; i <= 20; i++) {
System.out.println(i + "..." + Thread.currentThread().getName());
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
Runnable r3 = new Runnable() {
@Override
public void run() {
synchronized (obj) {
for (int i = 21; i <= 30; i++) {
System.out.println(i + "..." + Thread.currentThread().getName());
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
};
es.submit(r1);
es.submit(r2);
es.submit(r3);
// 已经提交的全部保证完成，不准继续提交了
// es.shutdown();// 已经提交的 前三个任务 保证完成，在shutdown之后就没法添加任务了
// es.submit(r3);
// es.shutdownNow();
// shutDownNow()：结束线程池，已经开始运行的，保证完成，等待的任务不保证完成
// 另外结束线程池这句话遇到任务中有sleep执行的时候就会有问题，会抛异常
// 可以把任务sleep的代码注释上 就不报错了
}
}
2525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
