java学习第二十天-CSDN博客

本文链接：https://blog.csdn.net/Gongshutong/article/details/128292260

多线程

1. 进程

执行的程序被称为一个进程
电脑中任何一个运行的软件是一个进程（qq,腾讯会议，eclipse，ev,…）
你做的一件事情就是一个进程（学习，做饭，打扫卫生）
一个人（单核cpu）在一个时刻只能做一件事情(进程)
宏观并行，微观串行
- 感觉上两个进行时一起执行的（两个楼房同时在建）
- 实际上同一时刻只建了其中一个

2. 线程

线程就是进程中一个步骤。

做菜：买菜，洗菜，切菜，炒菜，盛菜

打扫卫生：洗拖把，拖地，…

是CPU的基本调度单位
- cpu决定执行进程1，就是决定执行进程1中的哪一个线程
一个进程可以包含多个线程，至少包含一个线程
如果一个进程中包含多个线程，交替执行，称为多线程【如果只有一个线程，这就不是多线程】

1.1 进程和线程的区别

进程是系统资源调度的最小单位，线程是cup调度的最小单位
一个进程可以包含多个线程，至少包含一个线程
不同进程之间是数据隔离的，数据是安全
在同一个进程中多个线程
- 可以共享数据
  - 栈内存中的数据，是每个线程独享
  - 堆中的数据，可以共享

3 线程的创建

1. 继承Thread类

定义类继承Thread类
重写run方法
- 定义如果该线程被选择执行，执行的业务代码
- 如果run方法执行结束，该线程就over了
线程执行start()方法，表示开启该线程
- 该线程可以竞争cpu时间片段

class 类 extends Thread {
	
	public void run() {
		//线程被调用，执行的业务代码
	}
}

类 对象名 = new 类();
对象名.start();

package com.qfedu;

public class Demo02 {

	
	public static void main(String[] args) {
		
		//创建线程对象
		MyThread t1 = new MyThread();
		t1.setName("线程1");
		MyThread t2 = new MyThread();
		t2.setName("线程2");
		
		//开启线程
		t1.start();
		t2.start();
	}
	
}

/*
 * 1. 创建类继承Thread
 * 2. 重写run方法
 */
class MyThread extends Thread {
	
	@Override
	public void run() {
		
		for(int i=1; i<=100; i++) {
			
			try {
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			System.out.println(getName()+":"+i);
		}
		
	}
}

package com.qfedu;

public class Demo03 {

	public static void main(String[] args) {
		for(int i=1; i<=4; i++) {
			TickenWin win = new TickenWin("窗口"+i);
			win.start();
		}
	}
}
/*
 * 四个窗口，各买100张票
 */
class TickenWin extends Thread {
	public TickenWin(String name) {
		super(name);
	}
	@Override
	public void run() {
		
		int i = 1;  //一百张票
		
		while(i<=100) {
			
			try {
				Thread.sleep(10);  //休眠，模拟真实场景
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			System.out.println(getName()+"买了,第"+i+"张票");
			i++;
		}
		
	}
}

2. 实现Runnable

定义类实现Runnable接口
实现run()方法
调用Thread有参构造方法，创建对象
- 把Runnable接口实现类对象传到该有参构造方法中
- 可同时定义线程名称

class 类 implements Runnable {
	
	public void run() {
		//线程被调用，执行的业务代码
	}

}

类 对象名 = new 类();
Thread t = new Thread(对象名,"线程名称");
t.start();

package com.qfedu;

public class Demo04 {
	
	public static void main(String[] args) {
		
		Runnable runnable = new YourThread();
		
		/*
		Thread t1 = new Thread(runnable, "线程1");
		Thread t2 = new Thread(runnable, "线程2");
		Thread t3 = new Thread(runnable, "线程3");
		Thread t4 = new Thread(runnable, "线程4");
		
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		*/
		
		for(int i=1; i<=4; i++) {
			Thread t = new Thread(runnable, "线程"+i);
			t.start();
		}
		
	}

}

class YourThread implements Runnable {

	@Override
	public void run() {
		
		int i = 1;  
		
		while(i<=100) {  //一百张票
			
			try {
				Thread.sleep(10);  //休眠，模拟真实场景
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			System.out.println(Thread.currentThread().getName()+"买了,第"+i+"张票");
			i++;
		}
	}
}

2.1 共卖100张票问题

由于同一个进程中的多个线程可以共享堆中数据
我们把变量 i 由局部变量修改为成员变量保存在堆中

package com.qfedu;

public class Demo05 {

	/*
	 * 四个窗口共卖100张票
	 */
	public static void main(String[] args) {
		
		Runnable runnable = new HerThread();
		for(int i=1; i<=4; i++) {
			Thread t = new Thread(runnable, "窗口"+i);
			t.start();
		}
	}
}

class HerThread implements Runnable {
	
	int i = 1; 

	@Override
	public void run() {
		
		while(i<=100) {  //一百张票
			
			try {
				Thread.sleep(10);  //休眠，模拟真实场景
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			System.out.println(Thread.currentThread().getName()+"买了,第"+i+"张票");
			i++;
		}
	}
}

线程1被选择执行，在执行打印时，参数已经拼接好为线程1买了，第1张票时时间断开
1. i= 1
线程3被选择执行，在执行打印时，参数已经拼接好为线程3买了，第1张票时时间断开
1. i=1
线程2被选择执行，在执行线程2 买了，第1张票,然后执行 i++, 再次进行while判断时，断开
1. i=2
线程4被选择执行，在执行线程4 买了，第2张票,然后执行 i++, 再次进行while判断时，断开
1. i=3
线程3被选择执行，在执行打印线程3买了，第1张票后，i++后，再次进行while判断时，断开
1. i = 4
线程1被选择执行，在执行打印线程1买了，第1张票时, i++后，再次进行while判断时，断开
1. i= 5
线程2被选择执行，在执行线程2 买了，第5张票,然后执行 i++, 再次进行while判断时，断开

…

4. 线程状态1

创建一个线程对象，规定处于初始状态（新建状态）
- 不会竞争cpu的资源
执行start()方法，进入就绪状态
- 可以竞争cpu资源，执行run方法中的业务代码
被cpu选中了，就执行run方法中的业务代码,处于执行状态
- 如果没有执行结束，那就回到就绪状态，继续等待cpu分配资源
- 如果执行结束，该线程就死亡了

5. 线程常用方法

方法名	说明
public static void sleep(long millis)	当前线程主动休眠 millis 毫秒。
public static void yield()	当前线程主动放弃时间⽚，回到就绪状态，竞争下⼀次时间⽚。
public final void join()	允许其他线程加⼊到当前线程中。
public void setPriority(int)	public void setPriority(int)
线程优先级为1-10，默认为5,优先级越⾼，表示获取CPU机会越多。 public void setDaemon(boolean)	设置为守护线程线程有两类：⽤户线程（前台线程）、守护线程（后台线程）