进程和线程

进程：

​ 进程是系统进行资源分配和调用的独立单元，每一个进程都有它的独立内存空间和系统资源。

 

单进程操作系统和多进程操作系统的区别:

单进程操作系统：dos（一瞬间只能执行一个任务）
 
多进程单用户操作系统：Windows（一瞬间只能执行多个任务）
 
多进程多用户操作系统：Linux（一瞬间只能执行多个任务）

 
 

线程：

​ 线程是进程里面的一条执行路径，每个线程同享进程里面的内存空间和系统资源。

 

线程与进程的关系：

​ 一个进程 可以有 多个线程：各个线程都有不同的分工。

理解线程和进程的关系：

​ 进程 与 进程 之间的关系：进程之间的内存空间和系统资源是独立的。

​ 同一个进程里的多条线程 ：线程之间的内存空间和系统资源是共享的。

进程里：可以有一条或一条以上的线程。

​        进程里只有一条线程的情况下，这条线程就叫做主线程。

​        进程里有多条线程的情况下，只有一条线程叫做主线程。
 
Ps：线程是在进程里的，他们是包含关系。

 
 

创建线程方法：

1. 线程类

2. 任务类

3. 带返回值的任务类

4. 线程池

 

线程类:

步骤：
1.创建线程类（MyThread），继承Thread，重写run方法。

​ 2.创建子线程 – MyThread t = new MyThread();

​ 3.启动线程 ---- t.start();

public class MyThread extends Thread{

	//该线程的对象抢到CPU资源后，才会调用run方法
	@Override
	public void run() {
		System.out.println("MyThread类中的run方法被调用了");
	}
}

 

public static void main(String[] args) {
		
		//创建子线程
		MyThread t = new MyThread();
		
		//启动子线程
		t.start();
	}

 

 

任务类:

步骤：
1.创建任务类（Task），实现Runnable接口中的run方法
2.创建任务类对象 – Task task = new Task();
3.创建子线程，并把任务交给他 – Thread t = new Thread(task);
4.启动线程 – t.start();

public class Task implements Runnable{

	//线程对象抢到CPU资源后才会调用run方法
	@Override
	public void run() {
		System.out.println("Task类中的run方法被调用了");
	}

}

 

public static void main(String[] args) {
		
		//创建任务类对象
		Task task = new Task();
		
		//创建子线程，并把任务交给他
		Thread t = new Thread(task);
		
		//启动线程
		t.start();
	}

 
 

带返回值的任务类:

带有返回值的任务类和线程池一起使用。

计算任务，一个包含了2万个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。

import java.util.concurrent.Callable;

//带返回值的任务类
public class Task implements Callable<Integer>{
	
	private int[] arr;
	private int startIndex;
	private int endIndex;
	
	private int num;
	
	public Task(int[] arr, int startIndex, int endIndex,int num) {
		this.arr = arr;
		this.startIndex = startIndex;
		this.endIndex = endIndex;
		this.num = num;
	}

	//线程抢到CPU资源后，才会调用call方法，call方法相当于Runnable接口中的run方法
	@Override
	public Integer call() throws Exception {
		
		int sum = 0;
		for (int i = startIndex; i < endIndex; i++) {
			sum += arr[i];
			System.out.println("任务" + num);
		}
		return sum;
	}

}

 

public static void main(String[] args) throws InterruptedException, ExecutionException {
		
		//创建数组
		int[] arr = new int[20000];
		
		//初始化数组数据 -- {1,2,3,....,20000}
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i+1;
		}
		
		//创建线程池
		FastThreadPool pool = new FastThreadPool(4, 4, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5));
		
		//创建任务
		Task task1 = new Task(arr, 0, 5000,1);
		Task task2 = new Task(arr, 5000, 10000,2);
		Task task3 = new Task(arr, 10000, 15000,3);
		Task task4 = new Task(arr, 15000, 20000,4);
		
		//提交任务，任务完成后会返回Future对象，Future对象里存储了任务的返回值数据
		Future<Integer> future1 = pool.submit(task1);
		Future<Integer> future2 = pool.submit(task2);
		Future<Integer> future3 = pool.submit(task3);
		Future<Integer> future4 = pool.submit(task4);
		
		//合并任务返回值
		System.out.println(future1.get() + future2.get() + future3.get() + future4.get());
		
		
		pool.shutdown();
	}

 

线程池:

在后面的文章会继续更新线程池相关内容。

 

 

多线程争抢资源：

​ 编写一个多线程的应用程序，主线程打印1-100之间的数字，子线程打印200-300之间的数字，观察其输出的结果，体会多线程互相争抢资源的场景

public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 200; i <= 300; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

 
 

主线程在JVM虚拟中，主线程中调用main方法。

public static void main(String[] args) {
		
    	//子线程
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println("主线程：" + i);
		}
	}

 
 

线程的优先级别：

线程的优先级别：
 
​ 给线程定义抢到CPU资源的优先级。

tips:

​ 1.优先级别：1~10，数字越大，优先级越高。

​ 2.线程的优先级别不能决定线程是否优先抢到资源，优先级别只能影响（概率问题）。

 

在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

//A,B,C类都是一样的
public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}

 

public static void main(String[] args) {
		
		A a = new A();
		B b = new B();
		C c = new C();
		
		//设置优先级别
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}

 

 

线程名字：

在本类中添加私有属性: threadName

public class MyThread extends Thread{
	
	private String threadName;
	
	public MyThread(String threadName) {
		this.threadName = threadName;
	}

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println(threadName + "：" + i);
		}
	}
}

 

 

在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

public static void main(String[] args) {
		
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		
		//设置优先级别
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}

 

 

利用父类中的属性: name

public class MyThread extends Thread{
	
	public MyThread(String name) {
		super(name);
	}

	@Override
	public void run() {
		
		//获取当前线程对象
		Thread t = Thread.currentThread();
		
		for (int i = 1; i <= 100; i++) {
			System.out.println(t.getName() + "：" + i);
		}
	}
}

 

 

在主线程中创3个子线程，并且设置不同优先级，观察其优先级对线程执行结果的”影响”。

public static void main(String[] args) {
		
		MyThread a = new MyThread("A");
		MyThread b = new MyThread("B");
		MyThread c = new MyThread("C");
		
		//设置优先级别
		a.setPriority(Thread.MAX_PRIORITY);//10
		b.setPriority(Thread.NORM_PRIORITY);//5
		c.setPriority(Thread.MIN_PRIORITY);//1
		
		a.start();
		b.start();
		c.start();
		
	}

 

 

 

线程休眠：

Thread的静态方法 – sleep(毫秒)，表示让当前线程休眠。
 
​ Thread . sleep();

 

​ 编写一个抽取学员回答问题的程序，要求倒数三秒后输出被抽中的学员姓名。

public static void main(String[] args) throws InterruptedException {
		
		String[] names = {"小明","小红","小蓝","小绿","小黑","小白","小灰"};
		
		Random random = new Random();
		int index = random.nextInt(names.length);
		
		for(int i = 3;i>0;i--){
			System.out.println(i);
			
			//Thread的静态方法 -- sleep(毫秒)，表示让当前线程休眠，主线程休眠
			Thread.sleep(1000);
		}
		
		System.out.println(names[index]);
	}

 

 

线程礼让:

线程的礼让：hread.yield();
此方法为静态方法，此方法写在哪个线程中，哪个线程就礼让。

注意：

​ 所谓的礼让是指当前线程退出CPU资源，并转到就绪状态，接着再抢。

 

需求：创建两个线程A,B，分别各打印1-100的数字，其中B一个线程，每打印一次，就礼让一次，观察实验结果。

public class A extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("A：" + i);
		}
	}
}

 

public class B extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <= 100; i++) {
			System.out.println("B：" + i);
			
			//礼让：让当前线程退出CPU资源，当前线程退出后立刻转入抢资源的状态，可能又会抢到CPU资源
			Thread.yield();
		}
	}
}

 

public static void main(String[] args) {
		
		A a = new A();
		B b = new B();
		
		a.start();
		b.start();
	}

 

 

线程合并：

合并方法：
 
​ 线程 . join();

 

​ 主线程和子线程各打印200次，从1开始每次增加1，当主线程打印到10之后，让子线程先打印完再打印主线程。

public class MyThread extends Thread{

	@Override
	public void run() {
		for (int i = 1; i <=200; i++) {
			System.out.println("子线程：" + i);
		}
	}
}

 

public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		for (int i = 1; i <=200; i++) {
			System.out.println("主线程：" + i);
			if(i == 10){
				//让t线程加入到当前线程
				t.join();
			}
		}
		
	}

 

 

线程中断：

stop方法：

public class MyThread extends Thread{

	@Override
	public void run() {
		while(true){
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}

 

public static void main(String[] args) throws InterruptedException {
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		//立刻停止（缺点：可能会导致功能确实）
		t.stop();
		
		
		
	}

面试题：

​ 下列代码的子线程开启后，是否会在3000毫秒就被销毁？
​ 答：不一定，因为3000毫秒后主线程才休眠结束，这时会抢CPU资源，如果立刻抢到，那么子线程就是3000毫秒后销毁，如果没有抢到CPU资源，那么子线程会继续运行，直到主线程抢到CPU资源。

 

 

boolean属性：

设置boolean属性去控制run方法中的循环。
 
run方法结束，线程就会终止。

public class MyThread extends Thread{

	private boolean flag = true;
	
	public void setFlag(boolean flag) {
		this.flag = flag;
	}

	@Override
	public void run() {
		while(flag){
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}

 

public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		t.setFlag(false);
		
	}

 

 

isInterrupted方法:

public class MyThread extends Thread{


	@Override
	public void run() {
		
		//获取线程状态（是否消亡）
//		System.out.println(Thread.currentThread().isInterrupted());
		
		while(!Thread.currentThread().isInterrupted()){
			
			System.out.println("111");
			System.out.println("222");
			System.out.println("333");
			System.out.println("444");
		}
	}
}

 

public class Test01 {
	/**
	 * 知识点：线程的中断3
	 */
	public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
		t.start();
		
		Thread.sleep(3000);
		
		//改变线程状态,把线程状态改为消亡状态
		t.interrupt();
	}
	
}

 
 

守护线程：

守护线程 默默守护着前台线程，当所有的前台线程都消亡后，守护线程会自动消亡。

将当前线程设置为守护线程：t.setDaemon(true);

注意：Java的垃圾回收器就是个守护线程。

public class MyThread extends Thread{

	@Override
	public void run() {
		while(true){
			System.out.println("后台线程默默守护着前台线程");
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

 

public static void main(String[] args) throws InterruptedException {
		
		MyThread t = new MyThread();
    	//将当前线程设置为守护线程
		t.setDaemon(true);
		t.start();
		
		for (int i = 1; i <= 5; i++) {
			System.out.println("主线程：" + i);
			Thread.sleep(1000);
		}
		
	}

 

 

线程局部变量共享：

1. 共享单个数据
2. 共享多个数据

共享单个数据:

public class A {

	public void println(){
        //获取当前线程对象
		Thread t = Thread.currentThread();
        //获取当前线程对象对应的值
		Integer value = Test01.map.get(t);
		System.out.println(t.getName() + "里的A类对象获取了数据：" + value);
	}
}




public class B {

	public void println(){
		Thread t = Thread.currentThread();
		Integer value = Test01.map.get(t);
		System.out.println(t.getName() + "里的B类对象获取了数据：" + value);
	}
}

 

public static final ConcurrentHashMap<Thread, Integer> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 10;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				int i = 20;
				
				//存数据
				map.put(Thread.currentThread(), i);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
				
			}
		}, "线程2").start();
		
	}

 

 

共享多个数据:

public class A {

	public void println(){
		Thread t = Thread.currentThread();
		Data value = Test01.map.get(t);
		System.out.println(t.getName() + "里的A类对象获取了数据：" + value);
	}
}



public class B {

	public void println(){
		Thread t = Thread.currentThread();
		Data value = Test01.map.get(t);
		System.out.println(t.getName() + "里的B类对象获取了数据：" + value);
	}
}

 

//数据包类
public class Data {
	
	private int i;
	private String str;
	
	public Data() {
	}

	public Data(int i, String str) {
		this.i = i;
		this.str = str;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	@Override
	public String toString() {
		return "Data [i=" + i + ", str=" + str + "]";
	}
}

 

public static final ConcurrentHashMap<Thread, Data> map = new ConcurrentHashMap<>();
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data(10,"xxx");
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = new Data(20,"yyy");
				
				//存数据
				map.put(Thread.currentThread(), data);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
				
			}
		}, "线程2").start();
		
	}

共享多个数据: ThreadLocal

public class A {

	public void println(){
		Thread t = Thread.currentThread();
		/**
		 * 获取数据
		 * local.get()底层原理：
		 * 		1.获取当前线程对象
		 * 		2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>
		 * 		3.map.getEntry(this) -> Entry对象
		 * 		4.entry.getValue()
		 */
		Data value = Test01.local.get();
		System.out.println(t.getName() + "里的A类对象获取了数据：" + value);
	}
}




public class B {

	public void println(){
		Thread t = Thread.currentThread();
		Data value = Test01.local.get();
		System.out.println(t.getName() + "里的B类对象获取了数据：" + value);
	}
}

//数据包类
public class Data {
	
	private int i;
	private String str;
	
	private Data() {
	}

	private Data(int i, String str) {
		this.i = i;
		this.str = str;
	}
	
	//保证每个线程里只有一个Data包对象
	public static Data getInstance(int i,String str){
		Data data = Test01.local.get();//获取当前线程的Data对象
		if(data == null){
			data = new Data(i, str);
			Test01.local.set(data);
		}else{
			data.setI(i);
			data.setStr(str);
		}
		return data;
	}

	public int getI() {
		return i;
	}

	public void setI(int i) {
		this.i = i;
	}

	public String getStr() {
		return str;
	}

	public void setStr(String str) {
		this.str = str;
	}

	@Override
	public String toString() {
		return "Data [i=" + i + ", str=" + str + "]";
	}
}

public static final ThreadLocal<Data> local = new ThreadLocal<>();
	
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = Data.getInstance(10,"xxx");
				
				/**
				 * 存数据
				 * local.set(data)底层原理：
				 * 		1.获取当前线程对象
				 * 		2.通过当前线程对象获取ThreadLocalMap<ThreadLocal,T>(T是泛型，我们存的值)
				 * 		3.map.put(this,t)（this是ThreadLocalMap，t是线程对象）
				 */
				local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//10
				b.println();//10
			}
		},"线程1").start();
		
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				
				Data data = Data.getInstance(20,"yyy");
				data = Data.getInstance(30,"zzz");
				
				//存数据
				local.set(data);
				
				A a = new A();
				B b = new B();
				a.println();//20
				b.println();//20
				
			}
		}, "线程2").start();
		
	}

 

 

线程的生命周期：

1、新建状态

​        i. 在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态。新建一个线程对象可采用线程构造方法来实现。

​        ii. 例如：Thread thread=new Thread();

2、 就绪状态

​        i. 新建线程对象后，调用该线程的start()方法就可以启动线程。当线程启动时，线程进入就绪状态。此时，线程将进入线程队列排队，等待CPU调用，这表明它已经具备了运行条件。

3、运行状态

​        i. 当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态。此时，自动调用该线程对象的run()方法。run()方法定义了该线程的操作和功能。

4、 阻塞状态

​        i. 一个正在执行的线程在某些特殊情况下，如被人为挂起，将让出CPU并暂时中止自己的执行，进入阻塞状态。在可执行状态下，如果调用sleep(2000)、wait()等方法，线程都将进入阻塞状态。阻塞时，线程不能进入排队队列，只有当引起阻塞的原因被消除后，线程才可以转入就绪状态。

5、死亡状态

​        i. 线程调用stop()方法时或run()方法执行结束后，线程即处于死亡状态。处于死亡状态的线程不具有继续运行的能力。