Java 进程与线程，线程池

1.程序(Program)是为实现特定目标或解决特定问题而用计算机语言（比如Java语言）编写的命令序列的集合。
2.进程（process）指一个程序的一次执行过程。

import java.text.SimpleDateFormat;
import java.util.Date;

public class Program {
	public static void main(String[] args){
		try {
			Date date = new Date();
			String pattern = "yyyy-MM-dd HH:mm:ss";
			SimpleDateFormat sdf = new SimpleDateFormat(pattern);
			String currentTime = sdf.format(date);
			System.out.println(currentTime);//输出系统时间
			Thread.sleep(15000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

在任务栏右键，选择任务管理器，打开

3.执行上面代码三次，就会出现，任务管理器就会出现如下结果

4.线程（thread）又称为轻量级进程，线程运行在进程的独立的一个执行单元，存在于进程中，是一个进程的一部分。

package venu;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) {
		try {
			Thread.sleep(8000);
			new CountThread().start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class CountThread extends Thread{
	
	@Override
	public void run () {
	
		while(true) {
			Date date = new Date();
			String pattern = "yyyy-MM-dd HH:mm:ss";
			SimpleDateFormat sdf = new SimpleDateFormat(pattern);
			String currentTime = sdf.format(date);
			System.out.println(currentTime);//输出系统时间
			try {
				
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

运行的结果在任务管理器查看

运行的时候会出现13，然后运行 ，会出现下面14的情况，之后在eclipse上关闭控制台，它就会消失不见。

5.线程与进程的关系
①一个进程可以包含多个线程，而一个线程必须在一个进程之内运行；同一进程中的多个线程之间采用抢占式独立运行；进程结束，则线程跟着结束，如果一个进程没有可执行的线程，进程也结束；
②线程有独立的执行堆栈、程序计数器和局部变量；但是没有独立的存储空间，而是和所属进程中的其它线程共享存储空间；
③操作系统将进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位，由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统多个程序间并发执行的速度。
6.如何创建线程
①
class 类名 extends Thread{
//属性
public void run(){
//线程需要执行的核心代码
}
//其他方法
}

public class CounterThread extends Thread {

	public CounterThread() {
		super("计数器线程");//设置线程名称
	}

	public void run() {
		try {
			for (int i=1; i<=10; i++) {//输出10次，每次间隔0.5秒
				System.out.println(this.getName()+"运行第"+i+"次");
				Thread.sleep(1000);//使当前正在执行的线程休眠
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

另建一个类：

public class Test {

	public static void main(String[] args) {
		CounterThread counterThread = new CounterThread();   //创建新对象
		counterThread.start();
	}
}

②
class 类名 implements Runnable{
//属性
public void run(){
//线程需要执行的核心代码
}
//其他方法
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class TimeThread implements Runnable{

	String threadName = "时间线程";
	
	@Override
	public void run() {
		while(true){
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String currentTime = sdf.format(new Date());
			System.out.println(threadName+",当前时间："+currentTime);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

另一个类：

public class Test {

	public static void main(String[] args) {
		TimeThread    timeThread  =  new  TimeThread();
		Thread   thread  =  new  Thread(timeThread);
		thread.start();
	}
}

7.Java中，线程有5种不同状态，分别是：新建（New）、就绪（Runable）、运行（Running）、阻塞（Blocked）和死亡（Dead）。它们之间的转换图如下：

注意：线程实例调用start()方法并不意味着该线程立即进入了运行状态。
①新建状态（New）：新创建了一个线程对象。
②就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。
③运行状态（Running）：就绪状态的线程获取了CPU使用权，执行程序代码。
④阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
⑥等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)
⑦同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。
⑧其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）；
⑨死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
8.线程池
为什么有线程池：
①提高程序的执行效率；
如果程序中有大量短时间任务的线程任务，由于创建和销毁线程需要和底层操作系统交互，大量时间都耗费在创建和销毁线程上，因而比较浪费时间，系统效率很低；线程池里的每一个线程任务结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用，因而借助线程池可以提高程序的执行效率。
②控制线程的数量，防止程序崩溃；
如果不加限制地创建和启动线程很容易造成程序崩溃，比如高并发1000W个线程，JVM就需要有保存1000W个线程的空间，这样极易出现内存溢出；线程池中线程数量是一定的，可以有效避免出现内存溢出。

package venu;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test {

	public static void main(String[] args) {
		ExecutorService executorService = Executors.newFixedThreadPool(2);    //创建俩个
	    
		executorService.submit(()->{
			for(int i=0;i<5 ;i++) {
				System.out.println("次数&&&"+i);
				try {
					Thread.sleep(3000);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	
		executorService.submit(()->{
			for(int i=0;i<5 ;i++) {
				System.out.println("次数***"+i);
				try {
					Thread.sleep(2000);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
		
		executorService.submit(()->{
			for(int i=0;i<5 ;i++) {
				System.out.println("次数!!!"+i);
				try {
					Thread.sleep(3000);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	
		executorService.shutdown();   //调用这个方法，Java控制台会自动结束，不调用会一直显示红色，不结束
	}
}

运行结果：