Java基础27，28（多线程,ThreadMethod ,线程安全问题,线程状态,线程池）

现代操作系统（Windows，macOS，Linux）都可以执行多任务。多任务就是同时运行多个任务。例如：播放音乐的同时，浏览器可以进行文件下载，同时可以进行QQ消息的收发。
CPU执行代码都是一条一条顺序执行的，但是，即使是单核CPU，也可以同时运行多个任务。因为操作系统执行多任务实际上就是让CPU对多个任务轮流交替执行。
操作系统轮流让多个任务交替执行，例如，让浏览器执行0.001秒，让QQ执行0.001秒，再让音乐播放器执行0.001秒。在用户使用的体验看来，CPU就是在同时执行多个任务。

2. 进程与线程

2.1 程序

程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，可以理解为程序是包含静态代码的文件。例如：浏览器软件、音乐播放器软件等软件的安装目录和文件。

2.2 进程

进程是程序的一次执行过程，是系统运行程序的基本单位。在Windows系统中，每一个正在执行的exe文件或后台服务，都是一个进程，由操作系统统一管理并分配资源，因此进程是动态的。例如：正在运行中的浏览器就是一个进程，正在运行中的音乐播放器是另一个进程，同理，正在运行中的QQ和WPS等都是进程。
操作系统运行一个程序，即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如 CPU时间，内存空间，文件，输入输出设备的使用权等。

2.3 线程

某些进程内部还需要同时执行多个子任务。例如，我们在使用WPS时，WPS可以让我们一边打字，一边进行拼写检查，同时还可以在后台进行自动保存和上传云文档，我们把子任务称为线程。线程是进程划分成的更小的运行单位。
进程和线程的关系就是：一个进程可以包含一个或多个线程，但至少会有一个主线程。

2.4 进程与线程的区别

根本区别：进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位；
资源开销：每个进程都有独立的代码副本和数据空间，进程之间的切换，资源开销较大；线程可以看做轻量级的进程，每个线程都有自己独立的运行栈和程序计数器，线程之间切换，资源开销小；
包含关系：一个进程内包含有多个线程，在执行过程，线程的执行不是线性串行的，而是多条线程并行共同完成；
内存分配：同一进程内的所有线程共享本进程的内存空间和资源；进程之间的内存空间和资源相互独立；
影响关系：一个进程崩溃后，在保护模式下不会对其他进程产生影响；一个线程崩溃，会导致整个进程退出。所以多进程要比多线程健壮；
执行过程：每个独立的进程有程序运行的入口和程序出口。但是线程不能独立执行，必须依存在应用程序（进程）中，由应用程序提供多个线程执行控制；

3. 线程基本概念

单线程：单线程就是进程中只有一个线程。单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。
public static void main(String[] args) {
		int a =10;
		int b =20;
		int c=a+b;
		System.out.println(c);
	}
多线程：由一个以上的线程组成的程序称为多线程程序。Java中，一定是从主线程开始执行（main方法），然后在主线程的某个位置创建并启动新的线程。

作用：最主要是为了提高程序的运行效率
多线程应用场景：软件中耗时的操作拷贝,迁移文件,加载大量的时候

为什么要有多线程？
线程:操作系统能够进行调度的最小单元,他被包含在进程中,是进程中实际运行的单位
进程:进程是程序的基本执行实体

4.并发与并行

并发:在同一时刻,有多个指令在单个Cpu上交替执行
并行:在同一时刻,有多个指令在单个Cpu上同时执行

5. 线程的创建方式

方式一：继承Thread类

继承 java.lang.Thread 类（线程子类）

创建多线程的方法1:

自定义一个类继承Thread
重写run方法
创建子类的对象,并启动线程

MyThread类：


public class MyThread extends Thread {
	public MyThread() {
		super();
	}
	@Override
	public void run() {
		//写线程要执行的代码
		for (int i = 0; i < 100; i++) {
			System.out.println(getName()+"_hello");
		}
	}
}

Demo01类：


public class Demo01 {
	public static void main(String[] args) {
		/**
		*创建多线程的方法1:
		*1.自定义一个类继承Thread
		*2.重写run方法
		*3.创建子类的对象,并启动线程
		*/
		MyThread t1 = new MyThread();
		t1.setName("线程1");//给线程设置名称
		t1.start();//此处需要注意,不能直接调用run方法,否则就是对象的创建和方法的调用
		
		MyThread t2 = new MyThread();
		t2.setName("线程2");
		t2.start();
		
		for (int i = 0; i < 15; i++) {
			System.out.println(Thread.currentThread().getName()+"_world");
		}
	}
}

方式二：实现Runable接口

实现 java.lang.Runnable 接口（线程执行类）

创建多线程的方法2:

自己定义一个类实现Runable接口
重写里面的run方法
创建自己的类的对象
创建Thread类的对象,并开启线程

MyRun类：


public class MyRun implements Runnable {
	@Override
	public void run() {
		// 写线程要执行的代码
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName() + "_hello");
		}
	}
}

Demo02类：


public class Demo02 {
	public static void main(String[] args) {
		/**
		 * 1.自己定义一个类实现Runable接口 2.重写里面的run方法 3.创建自己的类的对象 4.创建Thread类的对象,并开启线程
		 */
		// 创建MyRun多线程,标识多线程要执行的任务
		MyRun run = new MyRun();
		// 创建线程
		Thread t1 = new Thread(run);
		Thread t2 = new Thread(run);
 
		t1.setName("线程1");
		t2.setName("线程2");
 
		t1.start();
		t2.start();
 
	}
}

方式三：实现Callable接口

实现 java.util.concurrent.Callable 接口，允许子线程返回结果、抛出异常

创建多线程的方法3:

创建Callable是实现类
重写ca11方法
创建Mycal1实现类的对象
创建FutureTask的对象(管理多线程运行的结果)
创建Thread对象,并启动

MyCall类：


public class MyCall implements Callable{
 
	//求1-100之间的和
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			sum+=i;
		}
		return sum;
	}
	
}

Demo03类：


public class Demo03 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
 
		/**
		 * 1.创建Callable是实现类
		 * 2.重写ca11方法 
		 * 3.创建Mycal1实现类的对象 
		 * 4.创建FutureTask的对象(管理多线程运行的结果)
		 * 5.创建Thread对象,并启动
		 */
 
		MyCall call1 = new MyCall();
		FutureTask ft = new FutureTask(call1);
		Thread t1 = new Thread(ft);
		t1.start();
 
		//获取多线程运行后的结果
		Integer result = ft.get();
		System.out.println(result);

方式四：线程池


 //通过线程池创建线程
    //ThreadPoolExecutor类:线程池
    // Executors类:工具类，用于创建各种参数配合的线程池
    // ExecutorService接口:定义线程池的行为
    public static void main(String[] args) {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
 
        //提交“线程任务”给线程池
        for (int i = 0; i < 100; i++) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程池中的" + Thread.currentThread().getName() + "开始执行。。。。");
                }
            });
        }
        //关闭线程池
        executorService.shutdown();

详情见线程池（见五、线程池）

小结:

继承Thread类

优点：编程比较简单,可以直接使用Thread类中的方法,

缺点：可扩展性比较差,不能再继承其他的类
实现Runable接口

优点：扩展性强,实现该接口后还可以同时继承其他类,实现其他的接口

缺点：编程相对比较复杂,不能直接使用Thread类中的方法
实现Callable接口

优点：有返回值,可以利用FutureTask进行结果的保存

缺点：编程相对比较复杂,不能直接使用Thread类中的方法



注意：直接调用Thread实例的run()方法是无效的，因为直接调用run()方法，相当于调用了一个普通的Java方法，当前线程并没有任何改变，也不会启动新线程。

二、ThreadMethod

1. Thread类常用的构造方法


public class MyThread extends Thread {
 
	public MyThread() {
		super();
	}
 
	public MyThread(String name) {
		super(name);
	}
 
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			try {
				sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(getName() + "@" + i);
		}
	}
}


Thread类常用的构造方法:
Thread()
Thread(String name)
Thread(Runnable run,String name,
Thread(Runnable run)


MyThread t1 = new MyThread();
// 通过构造方法创建线程
		MyThread t2 = new MyThread("线程2");

2. 线程的命名

生产环境中，为了排查问题方便，建议在创建线程的时候指定一个合理的线程名字

调用父类的setName()方法或在构造方法中给线程名字赋值；
// getName():获取线程名称
		// 细节:如果给线程没有设置名称,线程也有默认的名称 Thread-x(从0开始)
		// setName()设置线程的名称构造方法也可以设置线程的名称
		MyThread t1 = new MyThread();
		t1.setName("线程1");
如果没有为线程命名，系统会默认指定线程名，命名规则是Thread-N的形式

3. 获取当前线程

Thread.currentThread()


// Thread.currentThread()获取当前线程对象
		Thread tmain = Thread.currentThread();
		tmain.setName("核心线程");
		for (int i = 0; i < 20; i++) {
			System.out.println(tmain.getName() + "@" + i);
		}

4. 线程的休眠（暂停）

在线程中，可以通过调用Thread.sleep(long millis)，强迫当前线程按照指定毫秒值休眠。


public class Main {
 
    public static void main(String[] args) {
        System.out.println("main start...");
        
        Thread t = new Thread() {
            public void run() {
                System.out.println("thread run...");
                try {
                    Thread.sleep(10); // 子线程休眠10毫秒
                } catch (InterruptedException e) {}
                System.out.println("thread end.");
            }
        };
        t.start();
        
        try {
            Thread.sleep(20); // 主线程休眠20毫秒
        } catch (InterruptedException e) {}
        System.out.println("main end...");
 
    }
}

5. 线程的优先级

在线程中，通过setPriority(int n)设置线程优先级，范围是1-10，默认为 5
优先级高的线程被操作系统调度的优先级较高（操作系统对高优先级线程，调度更频繁）
注意：并不能代表，通过设置优先级来确保高优先级的线程一定会先执行

案例：


public static void main(String[] args) {
		//创建一个匿名内部类对象run
		Runnable run = new Runnable() {
 
			@Override
			public void run() {
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName() + "@" + i);
				}
			}
		};
 
		Thread t1 = new Thread(run, "线程1");
		Thread t2 = new Thread(run, "线程2");
 
		//获取线程的优先级：默认为5
		System.out.println(t1.getPriority());
		System.out.println("线程t2的优先级为" + t2.getPriority());
		System.out.println("主的优先级为：" + Thread.currentThread().getPriority());
 
		//设置优先级，优先级的取值范围1-10之间，优先级越高，抢到的线程概率越大，但并不是绝对的
		t1.setPriority(10);
		t2.setPriority(1);
		
		t1.start();
		t2.start();
 
	}

6. 守护线程（Daemon Thread）

用户线程与守护线程的区别

用户线程：我们平常创建的普通线程；
守护线程：用来服务于用户线程的线程，在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出；而守护线程执行结束后，虚拟机不会自动退出。

设置守护线程

守护线程:备胎线程--setDaemon(true)
细节:当其他的非守护的线程执行完毕后，守护线程会陆续结束
即(当女神线程结束，那么备胎线程也没有存在的必要)

在调用start()方法前，调用setDaemon(true)把该线程标记为守护线程


public static void main(String[] args) {
		
		//守护线程:备胎线程--setDaemon(true)
		//细节:当其他的非守护的线程执行完毕后，守护线程会陆续结束
		//即(当女神线程结束，那么备胎线程也没有存在的必要)
		
		//创建线程1
		Thread t1 = new Thread() {
			@Override
			public void run() {
				for (int i = 1; i <=10; i++) {
					System.out.println(getName()+"@"+i);
				}
			};
		};
		//创建线程2
		Thread t2 = new Thread() {
			@Override
			public void run() {
				for (int i = 1; i <=100; i++) {
					System.out.println(getName()+"@"+i);
				}
			};
		};
		
		//给线程设置名称
		t1.setName("女神");
		t2.setName("备胎");
		
		//将第二个线程设置为守护线程
		t2.setDaemon(true);
		
		t1.start();
		t2.start();
	}

7. 线程的让出：yield( )方法

线程通过调用yield()方法告诉JVM的线程调度，当前线程愿意让出CPU给其他线程使用。
○至于系统是否采纳，取决于JVM的线程调度模型：分时调度模型和抢占式调度模型

分时调度模型：所有的线程轮流获得 cpu的使用权,并且平均分配每个线程占用的 CPU 时间片；
抢占式调度模型：优先让可运行池中优先级高的线程占用 CPU，如果可运行池中的线程优先级相同，那么就随机选择一个线程，使其占用CPU。（JVM虚拟机采用的是抢占式调度模型）
public class MyThread1 extends Thread {
	//当前线程让出执行权后，再次进行抢夺也可能会抢夺到相关资源
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(getName() + "@" + i);
			//表示让出当前的cpu的执行权，会让结果更加均匀一点，但是并非绝对
			Thread.yield();//出让线程，礼让线程
		}
	}
}
public class Demo04 {
	public static void main(String[] args) {
		//创建线程1和线程2
		//出让线程，礼让线程Thread.yield();
		MyThread1 t1 = new MyThread1();
		MyThread1 t2 = new MyThread1();
		
		t1.setName("线程1");
		t2.setName("线程2");
		
		t1.start();
		t2.start();
 
 
		
	}
}

8. 线程的插队：join( )方法

t.join()方法会使当前线程( 主线程或者调用t.join()的线程 )进入等待池，并等待线程t 执行完毕后才会被唤醒。此时，并不影响同一时刻处在运行状态的其他线程。


public class Demo05 {
	public static void main(String[] args) throws InterruptedException {
		//线程对象.join();插队线程
		
		//此时土豆线程会和main线程抢占cpu的资源
		//如果土豆先执行，后执行main就用到join方法
		MyThread2 t1 = new MyThread2();
		t1.setName("土豆");
		t1.start();
		
		//表示把t1线程插入到当前的线程前面
		t1.join();
		for (int i = 0; i <=100; i++) {
			System.out.println(Thread.currentThread().getName()+"@"+i);
		}
	}
}
 
class MyThread2 extends Thread {
	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(getName() + "@" + i);
		}
	}
}

9. 小结

Thread线程的方法

getName()--有默认的线程名
setName()--给线程设置名称,构造方法也可以设置线程名
Thread.currentThread(),获取当前线程
getPriority() 获取线程的优先级1-10,默认的优先级为5
setPriority(int) 数字越大优先级越大
sleep(long mill) 睡眠
join() 插队线程
yield() 礼让线程
setDaemon(boolean) 守护线程

三、线程安全问题

多线程售票问题


public class MyThread extends Thread {
	//表示当前的变量提升到了类级别，所有的类共享此成员变量
	static int ticket = 0;
 
	@Override
	public void run() {
		// 卖票
		while (true) {
			if (ticket < 10) {
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				ticket++;
				System.out.println(getName() + "正在卖出第" + ticket + "张票");
 
			} else {
				break;
			}
		}
	}
}


public class Demo01 {
	public static void main(String[] args) {
		//线程在进行执行的过程中，cpu的执行权随时都可能被其他线程给抢走
		MyThread t1 = new MyThread();
		MyThread t2 = new MyThread();
		MyThread t3 = new MyThread();
 
		t1.setName("窗口1");
		t2.setName("窗口2");
		t3.setName("窗口3");
		
		//线程启动开始卖票
		t1.start();
		t2.start();
		t3.start();
 
 
	}
}

当多个线程同时运行时，线程的调度由操作系统决定，程序本身无法决定。因此，任何一个线程都有可能在任何指令处被操作系统暂停，然后在某个时间段后继续执行。
这个时候，一个在单线程模型下不存在的问题就会发生：如果多个线程同时读写共享变量，会出现数据不一致的问题。

解决方案1

解放方案1:锁代码块:


synchronized(锁对象){//锁对象可以是任意类型对象，但是必须要保证多个线程使用同一个锁
 操作的共享的数据资源
 }

默认下，锁是打开装填，有一个线程进来，锁自动关闭
里面的代码执行完毕，线程出来，锁自动打开


public class MyThread extends Thread {
	// 表示当前的变量提升到了类级别，所有的类共享此成员变量
	static int ticket = 0;
 
	//注意事项:锁对象要唯一
	static Object obj = new Object();
 
	@Override
	public void run() {
		// 卖票
		while (true) {
			synchronized (obj) {
				if (ticket < 1000) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					ticket++;
					System.out.println(getName() + "正在卖出第" + ticket + "张票");
				} else {
					break;
				}
			}
		}
	}
}

解决方案2

解放方案2:锁方法:


修饰符 synchronized 返回值类型 方法名(){
 括号内写的是共享的资源
}

1.特点:同步方法锁锁住的方法中的代码
2.特点:方法上面的锁不能自己指定,
实例方法:通过当前对象,作为“锁”
静态方法:通过当前类class字节码对象，作为“锁


public class MyThread extends Thread {
	// 表示当前的变量提升到了类级别，所有的类共享此成员变量
	static int ticket = 0;
 
	@Override
	public void run() {
		// 卖票
		while (true) {
			if (Method()) {
				break;
			}
		}
	}
 
	public static synchronized boolean Method() {
		if (ticket < 100) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			ticket++;
			System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票");
		} else {
			return true;
		}
		return false;
	}
}


public class Demo02 {
	public static void main(String[] args) {
		//MyRun作为Thread线程的参数进行传值
		MyRun run =new MyRun();
		Thread t1 = new Thread(run,"线程1");
		Thread t2 = new Thread(run,"线程2");
		Thread t3 = new Thread(run,"线程3");
		
		t1.start();
		t2.start();
		t3.start();
		
	}
}
class MyRun implements Runnable{
	static int ticket =0;
 
	@Override
	public void run() {
		while (true) {
			if (Method()) {
				break;
			}
		}
	}
	//此处锁对象为当前的对象
	public static synchronized boolean Method() {
		if (ticket < 10000) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			ticket++;
			System.out.println(Thread.currentThread().getName() + "正在卖出第" + ticket + "张票");
		} else {
			return true;
		}
		return false;
	}
}

解决方案3

解放方案3:Lock锁 1.5:

可以手动开锁关锁
lock();加锁
unlock();解锁


//Lock锁  1.5
//可以手动开锁关锁
//lock();加锁
//unlock();解锁
 
public class MyThread extends Thread {
	// 表示当前的变量提升到了类级别，所有的类共享此成员变量
	static int ticket = 0;
	static Lock lock = new ReentrantLock();
 
	@Override
	public void run() {
		while (true) {
			lock.lock();
			try {
				if (ticket < 100) {
					ticket++;
					System.out.println(getName() + "正在卖出第" + ticket + "张票");
				} else {
					break;
				}
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}finally {
				lock.unlock();
			}
		}
	}
 
}

四、线程状态

在Java程序中，一个线程对象通过调用start()方法启动线程，并且在线程获取CPU时，自动执行run()方法。run()方法执行完毕，代表线程的生命周期结束。
●在整个线程的生命周期中，线程的状态有以下6种：

New：新建状态，新创建的线程，此时尚未调用start()方法；
Runnable：运行状态，运行中的线程，已经调用start()方法，线程正在或即将执行run()方法；
Blocked：阻塞状态，运行中的线程，在等待竞争锁时，被阻塞，暂不执行；
Waiting：等待状态，运行中的线程，因为join()等方法调用，进入等待；
Timed Waiting：计时等待状态，运行中的线程，因为执行sleep(等待毫秒值)join(等待毫秒值)等方法，进入计时等待；
Terminated：终止状态，线程已终止，因为run()方法执行完毕。

●当线程启动后，它可以在Runnable、Blocked、Waiting和Timed Waiting这几个状态之间切换，直到最后变成Terminated状态，线程终止

线程终止的原因有：
○线程正常终止：run()方法执行到return语句返回；
○线程意外终止：run()方法因为未捕获的异常导致线程终止；
○对某个线程的Thread实例调用stop()方法强制终止（宇宙超级无敌强烈不推荐）；

1. New：新建状态

新建状态:线程对象创建，还没有调用start方法的时候


//新建状态:线程对象创建，还没有调用start方法的时候
public class NewState {
	public static void main(String[] args) {
		Thread thread = new Thread() {
			@Override
			public void run() {
				System.out.println("正在执行某件任务");
			};
		};
		System.out.println(thread.getState());//NEW
	}
}

2. Runnable：运行状态

线程对象调用start()方法，处于等待CPU分配资源，running ready


//线程对象调用start()方法，处于等待CPU分配资源，running ready
public class RunState {
	public static void main(String[] args) {
		Thread thread = new Thread() {
			@Override
			public void run() {
				System.out.println("正在执行某件任务");
			};
		};
		thread.start();
		System.out.println(thread.getState());// RUNNABLE
	}
}

3. Terminated：终止状态

TERMINATED操作系统注销此


//TERMINATED操作系统注销此
public class TerminatedState {
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread() {
			@Override
			public void run() {
				System.out.println("正在执行某件任务");
			};
		};
		thread.start();
		Thread.sleep(1000);
		System.out.println(thread.getState());//TERMINATED
	}
}

4. Blocked：阻塞状态

运行中的线程，在等待竞争锁时，被阻塞，暂不执行


public class BlockedState {
	public static void main(String[] args) throws InterruptedException {
		Runnable run = new Runnable() {
 
			@Override
			public void run() {
				synchronized (this) {
					//死循环
					while (true);
				}
			}
		};
 
		//创建线程t1和t2,并启动线程
		Thread t1 = new Thread(run, "t1");
		Thread t2 = new Thread(run, "t2");
 
		t1.start();
		t2.start();
 
		//让主线程睡眠1秒，目的想让t1和t2同时竞争一个锁
		Thread.sleep(1000);
 
		System.out.println("t1 state" + t1.getState());
		System.out.println("t2 state" + t2.getState());
	}
}

5. Timed Waiting：计时等待状态

运行中的线程，因为执行sleep(等待毫秒值)join(等待毫秒值)等方法，进入计时等待；


//	wait()
//	notify()
//	notifyA11()
//注意事项:
//1.要和synchronized写在一起
//2.锁对象要和调用的对象保持一致
 
 
//TIMED WAITING计时等待
//执行sleep(1ong millis)等方法	不会释放锁资源
//执行wait(long millis)等方法	会释放所资源
// join(等待时间)
public class TimeWaitingState {
	public static void main(String[] args) throws InterruptedException {
		Runnable run = new Runnable() {
 
			@Override
			public void run() {
				synchronized (this) {
					System.out.println(Thread.currentThread().getName());
					try {
//						Thread.sleep(5000);
						this.wait(5000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		};
 
		Thread t1 = new Thread(run, "t1");
		Thread t2 = new Thread(run, "t2");
 
		// 期待线程，观察sleep方法和wait方法对比
		t1.start();
		t2.start();
 
		// 让当前线程睡眠1秒
		Thread.sleep(1000);
 
		// 获取线程状态
		System.out.println(t1.getState());
		System.out.println(t2.getState());
	}
}


//Object 类
//	wait(long)
//	wait()
 
//TIMED WAITING计时等待
//执行sleep(long millis)等方法	不会释放锁资源
//执行wait(long millis)等方法	会释放所资源
//执行 join(等待时间)
public class TimeWaitingState02 {
	public static void main(String[] args) throws InterruptedException {
		Thread thread = new Thread() {
 
			@Override
			public void run() {
				Thread t1 = new Thread() {
					@Override
					public void run() {
						System.out.println("t1线程");
 
					};
				};
				t1.start();
				//join方法会让当前的线程处于计时等待
				try {
					t1.join(500 * 1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
 
			};
		};
 
		thread.start();
		Thread.sleep(1000);
 
		//查看thread线程的状态
		System.out.println(thread.getState());
	}
}

6. Waiting：等待状态

运行中的线程，因为join()等方法调用，进入等待；


//WAITING 等待状态 wait()
//                join()
 
//Oject中的wait() wait(long time)
//1.synchronized写在一起
//2.锁对象要和调用的对象保持一致
public class WaitingState01 {
	public static void main(String[] args) throws InterruptedException {
		Object obj = new Object();
		Thread t1 = new Thread() {
			public void run() {
				synchronized (obj) {
					try {
						obj.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			};
		};
		
		t1.start();
		Thread.sleep(1000);
		System.out.println(t1.getState());//WAITING
	}
}


//Oject中的wait() wait(long time)
// 1.synchronized写在一起
// 2.锁对象要和调用的对象保持一致
public class WaitingState02 {
	public static void main(String[] args) throws InterruptedException {
		Thread t1 = new Thread() {
			@Override
			public void run() {
				while (true)
					;
			}
		};
		t1.start();
		t1.join();//t1加到当前的主线程的前面，主线程一直处于等待状态
		
		//获取不到，因为当前的主线程被t1线程插队,t1线程任务是个死循环，无法结束
		System.out.println(Thread.currentThread().getState());
	}
}

五、线程池

1. 什么是线程池？

线程池内部维护了若干个线程，没有任务的时候，这些线程都处于等待空闲状态。如果有新的线程任务，就分配一个空闲线程执行。如果所有线程都处于忙碌状态，线程池会创建一个新线程进行处理或者放入队列（工作队列）中等待。

线程池：线程池是一个可以复用线程的技术

2. 线程池常用类和接口

在Java标准库提供了如下几个类或接口，来操作并使用线程池：

ExecutorService接口：进行线程池的操作访问；
Executors类：创建线程池的工具类；
ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制；

MyRunable类：


public class MyRunable implements Runnable {
 
	public MyRunable() {
 
	}
 
	public MyRunable(String name) {
 
	}
 
	@Override
	public void run() {
		// TODO Auto-generated method stub
 
	}
 
}

线程池的基本使用方式：


//线程池：线程池是一个可以复用线程的技术
//1. ExecutorService接口：进行线程池的操作访问；
//    submit()
//    execute()
//2. Executors类：创建线程池的工具类；
//		Executors.newCachedThreadPool()  创建一个线程没有上线的线程池
//3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制；
public class Demo01 {
	public static void main(String[] args) throws InterruptedException {
		// 创建一个线程没有上限的线程池
		ExecutorService pool1 = Executors.newCachedThreadPool();
 
		// 线程池提交任务
		pool1.execute(new MyRunable());
//		Thread.sleep(1000);
		pool1.execute(new MyRunable());
//		Thread.sleep(1000);
		pool1.execute(new MyRunable());
//		Thread.sleep(1000);
		pool1.execute(new MyRunable());
 
		// 销毁线程--用完后线程池给砸了
		 pool1.shutdown();
	}
 
}

3. 线程池常见方法

执行无返回值的线程任务：void execute(Runnable command);
提交有返回值的线程任务：Future submit(Callable task);
关闭线程池：void shutdown(); 或 shutdownNow();
等待线程池关闭：boolean awaitTermination(long timeout, TimeUnit unit);

执行线程任务

execute()只能提交Runnable类型的任务，没有返回值，而submit()既能提交Runnable类型任务也能提交Callable类型任务，可以返回Future类型结果，用于获取线程任务执行结果。
execute()方法提交的任务异常是直接抛出的，而submit()方法是捕获异常，当调用Future的get()方法获取返回值时，才会抛出异常。


//线程池：线程池是一个可以复用线程的技术
//1. ExecutorService接口：进行线程池的操作访问；
//  submit()--提交任务 Runable Callable
//  execute()--提交任务Runable
//2. Executors类：创建线程池的工具类；
//		Executors.newCachedThreadPool()  创建一个线程没有上限的线程池
//		Executors.newFixedThreadPool(int nThreads) 创建一个有上限的线程池
//3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制；
 
public class Demo02 {
	public static void main(String[] args) {
//		Executors.newFixedThreadPool(int nThreads) 创建一个有上限的线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);
	
		pool.submit(new MyRunable("任务1"));
		pool.submit(new MyRunable("任务2"));
		pool.submit(new MyRunable("任务3"));
		pool.submit(new MyRunable("任务4"));
	}
 
}

MyCallable类：


public class MyCallable implements Callable{
    private int number;
    
     public MyCallable(int number) {
		this.number = number;
	}
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= number ; i++) {
			sum+=i;
		}
		return sum;
	}
 
}


//线程池：线程池是一个可以复用线程的技术
//1. ExecutorService接口：进行线程池的操作访问；
//    submit()--提交任务 Runable Callable
//    execute()--提交任务Runable
//2. Executors类：创建线程池的工具类；
//		Executors.newCachedThreadPool()  创建一个线程没有上线的线程池
//		Executors.newFixedThreadPool(int nThreads) 创建一个有上线的线程池
//      核心线程数量到底配置多少：计算密集型任务: =CPU的核数+1;    IO密集型任务: CPU的核数*2
//3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制；
 
public class Demo03 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建一个有上线的线程的线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);
		
		//测试submit的方法--传callable值
		Future futureTask1 = pool.submit(new MyCallable(10));
		Future futureTask2 = pool.submit(new MyCallable(100));
		Future futureTask3 = pool.submit(new MyCallable(1000));
 
        System.out.println(futureTask1.get());//55
        System.out.println(futureTask2.get());//5050
        System.out.println(futureTask3.get());//500500
	}
 
}

4. 线程池分类总结

FixedThreadPool

线程数固定的线程池

线程池参数：

核心线程数和最大线程数一致
非核心线程线程空闲存活时间，即keepAliveTime为0
阻塞队列为无界队列LinkedBlockingQueue

工作机制：

提交线程任务
如果线程数少于核心线程，创建核心线程执行任务
如果线程数等于核心线程，把任务添加到LinkedBlockingQueue阻塞队列
如果线程执行完任务，去阻塞队列取任务，继续执行

使用场景：适用于处理CPU密集型的任务，确保CPU在长期被工作线程使用的情况下，尽可能的少的分配线程，即适用执行长期的任务。

CachedThreadPool

可缓存线程池，线程数根据任务动态调整的线程池
线程池参数：

核心线程数为0
最大线程数为Integer.MAX_VALUE
工作队列是SynchronousQueue同步队列
非核心线程空闲存活时间为60秒

●工作机制：

提交线程任务
因为核心线程数为0，所以任务直接加到SynchronousQueue工作队列
判断是否有空闲线程，如果有，就去取出任务执行
如果没有空闲线程，就新建一个线程执行
执行完任务的线程，还可以存活60秒，如果在这期间，接到任务，可以继续存活下去；否则，被销毁。

使用场景：用于并发执行大量短期的小任务。

SingleThreadExecutor

单线程化的线程池
线程池参数：

核心线程数为1
最大线程数也为1
阻塞队列是LinkedBlockingQueue
非核心线程空闲存活时间为0秒

使用场景：适用于串行执行任务的场景，将任务按顺序执行。

ScheduledThreadPool

能实现定时、周期性任务的线程池
线程池参数：

最大线程数为Integer.MAX_VALUE
阻塞队列是DelayedWorkQueue
keepAliveTime为0

使用场景：周期性执行任务，并且需要限制线程数量的需求场景。


//线程池：线程池是一个可以复用线程的技术
//1. ExecutorService接口：进行线程池的操作访问；
//    submit()
//    execute()
//2. Executors类：创建线程池的工具类；
//		Executors.newCachedThreadPool()  创建一个线程没有上线的线程池，如果任务执行完线程空闲60秒会被回收
//		Executors.newFixedThreadPool(int nThreads) 创建一个有上线的线程池
//		Executors.newSingleThreadExecutor()创建一个只有一个线程的线程池对象
//		Executors.newScheduledThreadPool() 创建一个线程池，可以实现在给时间延后执行或者定期执行任务
//3. ThreadPoolExecutor及其子类：封装线程池的核心参数和运行机制；
 
 
public class Demo04 {
	public static void main(String[] args) {
//		创建只有一个线程的线程池
//		ExecutorService pool=Executors.newSingleThreadExecutor();
//		pool.submit(new MyRunable("任务1"));
//		pool.submit(new MyRunable("任务2"));
		
		//1.创建任务调度线程池对象
		ScheduledExecutorService pool1=Executors.newScheduledThreadPool(2);
		Runnable run = new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName());
			}
		};
		//提交任务，延时5秒执行
//		pool1.schedule(run,5,TimeUnit.SECONDS);
		//提交任务，延时5秒，以后每1秒执行1次
		pool1.scheduleAtFixedRate(run, 5, 1,TimeUnit.SECONDS);
	}
 
}

5. 线程池的配置参数

●corePoolSize线程池核心线程数：也可以理解为线程池维护的最小线程数量，核心线程创建后不会被回收。大于核心线程数的线程，在空闲时间超过keepAliveTime后会被回收；

在创建了线程池后，默认情况下，线程池中并没有任何线程，当调用 execute() 方法添加一个任务时，如果正在运行的线程数量小于corePoolSize，则马上创建新线程并运行这个任务。
IO密集计算：由于 I/O 设备的速度相对于 CPU来说都很慢，所以大部分情况下，I/O 操作执行的时间相对于 CPU 计算来说都非常长，这种场景我们一般都称为 I/O 密集型计算。最佳线程数 =CPU 核数 * [ 1 +（I/O 耗时 / CPU 耗时）]。
CPU密集型：CPU 密集型计算大部分场景下都是纯 CPU 计算，多线程主要目的是提升CPU利用率，最佳线程数 =“CPU 核心数 +1”。这样的话，当线程因为偶尔的内存页失效或其他原因导致阻塞时，这个额外的线程可以临时替补，从而保证 CPU 的利用率。

●maximumPoolSize线程池最大线程数：线程池允许创建的最大线程数量；（包含核心线程池数量）
●keepAliveTime非核心线程线程存活时间：当一个可被回收的线程的空闲时间大于keepAliveTime，就会被回收。

当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会被回收，直到线程池中的线程数不超过corePoolSize。
如果设置allowCoreThreadTimeOut = true，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；

●TimeUnit时间单位：参数keepAliveTime的时间单位；
●BlockingQueue阻塞工作队列：用来存储等待执行的任务；
●ThreadFactory线程工厂 : 用于创建线程，以及自定义线程名称，需要实现ThreadFactory接口；
●RejectedExecutionHandler拒绝策略：当线程池线程内的线程耗尽，并且工作队列达到已满时，新提交的任务，将使用拒绝策略进行处理；

ThreadPoolExecutor.AbortPolicy：默认策略，丢弃任务并抛出RejectedExecutionException异常；
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常；
ThreadPoolExecutor.DiscardOldestPolicy：丢弃工作队列中的队头任务（即最旧的任务，也就是最早进入队列的任务）后，继续将当前任务提交给线程池；
ThreadPoolExecutor.CallerRunsPolicy：由原调用线程处理该任务（谁调用，谁处理）；

MyRun 类:


public class MyRun implements Runnable {
	private String name;
 
	public MyRun() {
 
	}
 
	public MyRun(String name) {
		this.name = name;
	}
 
	@Override
	public void run() {
		System.out.println(Thread.currentThread().getName()+ name + "======>" + "正在执行");
 
		// 让任务稍微慢点，便于观察结果
		try {
			Thread.sleep(Integer.MAX_VALUE);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
}


//线程池的创建方式2：
//    new ThreadPoolExecutor
 
public class Demo01 {
	public static void main(String[] args) {
//		corePoolSize:线程核心数量
//		maximumPoolSize:线程池中最大的线程数
//		keepAliveTime：临时线程的存活时间
//		unit,时间单位(时，分，秒)
//		workQueue, 任务队列
//		threadFactory, 为线程池创建线程的线程工厂
//		handler:指定线程池的拒绝策略
//		    1.AbortPolicy--丢弃任务并抛出异常，默认拒绝策略
//		    2.CallerRunsPolicy--由主线程负责调用run方法，绕过线程池
//		    3.DiscardOldestPolicy--抛弃队列中等待最久的任务，把当前的任务加入到队列
//		    4.DiscardPolicy--丢弃任务，不抛出异常，不推荐
		ExecutorService pool = new ThreadPoolExecutor(
				3, 6, 60, 
				TimeUnit.SECONDS, new ArrayBlockingQueue(3),
				Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
 
//		MyRun run = new MyRun();
		pool.execute(new MyRun("任务1"));//提交第一个任务，线程池会自动创建一个新的线程，自动处理任务
		pool.execute(new MyRun("任务2"));
		pool.execute(new MyRun("任务3"));
		pool.execute(new MyRun("任务4"));//提交第4个任务时候,进入等待队列中
		pool.execute(new MyRun("任务5"));
		pool.execute(new MyRun("任务6"));
		pool.execute(new MyRun("任务7"));//提交第7个任务的时候，核心线程数已满，队列已满，再来新任务，看临时工
		pool.execute(new MyRun("任务8"));//
		pool.execute(new MyRun("任务9"));
		pool.execute(new MyRun("任务10"));//核心线程满，队列满，临时满
		pool.execute(new MyRun("任务11"));
	}
 
}


//线程池的创建方式2：
//    new ThreadPoolExecutor
 
public class Demo02 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
//		corePoolSize:线程核心数量
//		maximumPoolSize:线程池中最大的线程数
//		keepAliveTime：临时线程的存活时间
//		unit,时间单位(时，分，秒)
//		workQueue, 任务队列
//		threadFactory, 为线程池创建线程的线程工厂
//		handler:指定线程池的拒绝策略
//		    1.AbortPolicy--丢弃任务并抛出异常，默认拒绝策略
//		    2.CallerRunsPolicy--由主线程负责调用run方法，绕过线程池
//		    3.DiscardOldestPolicy--抛弃队列中等待最久的任务，把当前的任务加入到队列
//		    4.DiscardPolicy--丢弃任务，不抛出异常，不推荐
		ExecutorService pool = new ThreadPoolExecutor(3, 6, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(3),
				Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
 
		
		Future f1=pool.submit(new MyCall(10));
		Future f2=pool.submit(new MyCall(20));
		Future f3=pool.submit(new MyCall(30));
	
	
		System.out.println(f1.get());
		System.out.println(f2.get());
		System.out.println(f3.get());
	}
}
 
class MyCall implements Callable {
	private int number;
 
	public MyCall(int number) {
		this.number = number;
	}
 
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= number; i++) {
			sum += i;
		}
		return sum;
	}
 
}


public class Demo03 {
	public static void main(String[] args) {
//		corePoolSize:线程核心数量
//		maximumPoolSize:线程池中最大的线程数
//		keepAliveTime：临时线程的存活时间
//		unit,时间单位(时，分，秒)
//		workQueue, 任务队列
//		threadFactory, 为线程池创建线程的线程工厂
//		handler:指定线程池的拒绝策略
//		    1.AbortPolicy--丢弃任务并抛出异常，默认拒绝策略
//		    2.CallerRunsPolicy--由主线程负责调用run方法，绕过线程池
//		    3.DiscardOldestPolicy--抛弃队列中等待最久的任务，把当前的任务加入到队列
//		    4.DiscardPolicy--丢弃任务，不抛出异常，不推荐
		ThreadPoolExecutor pool = new ThreadPoolExecutor(
				3, 6, 60, 
				TimeUnit.SECONDS, new ArrayBlockingQueue(3),
				new MyThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
 
//		MyRun run = new MyRun();
		pool.execute(new MyRun("任务1"));//提交第一个任务，线程池会自动创建一个新的线程，自动处理任务
		pool.execute(new MyRun("任务2"));
		pool.execute(new MyRun("任务3"));
		
		ThreadPoolExecutor pool1 = new ThreadPoolExecutor(
				3, 6, 60, 
				TimeUnit.SECONDS, new ArrayBlockingQueue(3),
				new MyThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
 
//		MyRun run = new MyRun();
		pool1.execute(new MyRun("任务1"));//提交第一个任务，线程池会自动创建一个新的线程，自动处理任务
		pool1.execute(new MyRun("任务2"));
		pool1.execute(new MyRun("任务3"));
 
	}
 
}
 
 class MyThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
 
    MyThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "池子-" +
                      poolNumber.getAndIncrement() +
                     "-线程-";
    }
 
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

6. 线程池的执行流程

1. 提交一个新线程任务，线程池会在线程池中分配一个空闲线程，用于执行线程任务；
2. 如果线程池中不存在空闲线程，则线程池会判断当前“存活的线程数”是否小于核心线程数corePoolSize。
        ○如果小于核心线程数corePoolSize，线程池会创建一个新线程（核心线程）去处理新线程任务；
        ○如果大于核心线程数corePoolSize，线程池会检查工作队列；

                ■如果工作队列未满，则将该线程任务放入工作队列进行等待。线程池中如果出现空闲线程，将从工作队列中按照FIFO的规则取出1个线程任务并分配执行；
                ■如果工作队列已满，则判断线程数是否达到最大线程数maximumPoolSize；
                        ●如果当前“存活线程数”没有达到最大线程数maximumPoolSize，则创建一个新线程（非核心线程）执行新线程任务；
                ●如果当前“存活线程数”已经达到最大线程数maximumPoolSize，直接采用拒绝策略处理新线程任务；
综上所述，执行顺序为：核心线程、工作队列、非核心线程、拒绝策略。

7. 线程池的状态

线程池的状态分为：RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED

○ RUNNING ：运行状态，线程池被一旦被创建，就处于RUNNING状态，并且线程池中的任务数为0。该状态的线程池会接收新任务，并处理工作队列中的任务。
调用线程池的shutdown()方法，可以切换到SHUTDOWN关闭状态；

调用线程池的shutdownNow()方法，可以切换到STOP停止状态；

○SHUTDOWN：关闭状态，该状态的线程池不会接收新任务，但会处理工作队列中的任务；

当工作队列为空时，并且线程池中执行的任务也为空时，线程池进入TIDYING状态；

○STOP：停止状态，该状态的线程不会接收新任务，也不会处理阻塞队列中的任务，而且会中断正在运行的任务；

线程池中执行的任务为空,进入TIDYING状态;

○TIDYING：整理状态，该状态表明所有的任务已经运行终止，记录的任务数量为0；

terminated()执行完毕，进入TERMINATED状态；

○TERMINATED: 终止状态，该状态表示线程池彻底关闭。

相关阅读:
开发工程师必备————【Day15】python操作Mysql及SQL语法补充
 kafka、zookeeper、flink测试环境、docker
前端进击笔记第二十四节如何进行技术方案调研与设计？
STM32实战总结：HAL之I2C
[Java框架] Java常用爬虫框架推荐
 在Android工程中的.gitignore对.gradle目录失效问题解决
 如何清理mac磁盘空间？该删不该删的你都知道了吗
 springboot 老年人健康保障管理系统毕业设计源码302303
C#面：关于集合的几个选择题
 餐饮美食网页设计(HTML+CSS+JavaScript)
原文地址：https://blog.csdn.net/qq_52897007/article/details/139410396