1.基本概念:程序、进程、线程
1.1 程序、进程、线程
1.1.1 程序
程序是为完成特定任务、用某种语言编写的一组指令的集合。
即指一段静态的代码,静态对象。
1.1.2 进程
进程是程序的一次执行过程,或是正在运行的一个程序。
是一个动态的过程:有它自身的产生、存在和消亡的过程。———生命周期
》程序是静态的,进程是动态的
》进程作为资源分配的单位,系统在运行时会为每个进程分配不同的内存区域
1.1.3 线程
进程可进一步细化为线程,是一个程序内部的一条执行路径。
》若一个进程同一时间并行执行多个线程,就是支持多线程的
》线程作为调度和执行的单位,每个线程拥有独立的运行栈和程序计数器(pc),线程切换的开销小
》一个进程中的多个线程共享相同的内存单元/内存地址空间≥它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。
但多个线程操作共享的系统资源可能就会带来安全的隐患。
1.2 图示
1.3 题外话
1.3.1 单核CPU和多核CPU的区别:
单核CPU就是在相互切换,只不过速度太快了,
感觉不出来,所以本质上还是多核更好。
一个Java应用程序java.exe其实至少有三个线程:
main()主线程,gc()垃圾回收线程,异常处理线程。
当然如果发生异常,会影响主线程。
1.3.2 并行与并发
并行:
多个CPU同时执行多个任务。
比如:多个人同时做不同的事。
并发:
一个CPU(采用时间片)同时执行多个任务。
比如:秒杀、多个人做同一件事。
2.线程的创建和使用(重点)
2.1线程的创建和启动
Java语言的JVM允许程序运行多个线程,
它通过java.lang.Thread类来体现。
2.1.1Thread类的特性
- 每个线程都是通过某个特定Thread对象的run()方法来完成操作的,经常把run()方法的主体称为线程体
- 通过该Thread对象的start()方法来启动这个线程,而非直接调用run()
2.2多线程创建,方式一:继承于Thread类
2.2.1步骤
- 创建一个继承于Thread类的子类
- 重写Thread类的run()
- 创建Thread类的子类的对象
- 通过此对象调用start():
(1)启动当前线程(2)调用当前线程的run()
2.2.2举例:
/**
* 例子: 遍历100以内的所有偶数
*/
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{ //新的线程 分线程
//2.重写Thread类的run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {//主线程
//3.创建Thread类的子类的对象
MyThread t1 = new MyThread();
//4.通过此对象调用start()
t1.start();
// t1.run();//问题一
// t1.start();//问题二
// 问题二:解决方案,需要重新创建一个线程的对象
new MyThread().start();
//如下操作仍然是在main线程中执行
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" +
i + "*********main()*********");
}
}
}
}
执行顺序:
首先main方法主线程先进来 造对象调方法
调完以后开始执行另一个线程 独立执行 run
main里的循环还是在主线程接着往下执行
主线程和分线程同时执行 输出语句就不确定什么时候执行了
结果大概是:
main:0*********main()*********
main:2*********main()*********
main:4*********main()*********
Thread-1:0
Thread-0:0
Thread-1:2
main:6*********main()*********
Thread-1:4
。。。
问题一: 我们不能通过直接调用run()的方式启动线程。
t1.run();》还是单线程没有开辟新的线程 只是体现了对象调方法
问题二: 再启动一个线程,遍历100以内偶数
不可以还让已经start()的线程去执行。会报IllegalThreadStateException
对于线程来说 只能start一次
解决方案 :需要重新创建一个线程的对象
2.2.3 优化
如果有多种功能,比如有两个分线程,这时候可以为了省事
》可以使用创建Thread类的匿名子类的方式
new Thread(){
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}.start();
//第二个根据第一个再次优化:
new Thread(() -> {
for (int i = 0; i < 100; i++) {
if (i % 2 !=0){
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}).start();
2.3多线程创建,方式二:实现Runnable接口
2.3.1步骤
- 创建一个实现了Runnable接口的类
- 实现类去实现Runnable中的抽象方法: run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中,
创建Thread类的对象 - 通过Thread类的对象调用start():
(1)启动线程
(2)调用当前线程的run()–>调用了Runnable类型的target的run()
2.3.2举例:
/**
* 创建多线程的方式二:实现Runnable接口
*/
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable {
//2.实现类去实现Runnable中的抽象方法: run()
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" + i);
//这边Thread.currentThread().不能省略
}
}
}
}
public class ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread mThread = new MThread();
//4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(mThread);
t1.setName("线程1");
//5.通过Thread类的对象调用start():
//1.启动线程 2.调用当前线程的run()-->调用了Runnable类型的target的run()
t1.start();
//再启动一个线程,遍历100以内的偶数
Thread t2 = new Thread(mThread);
t2.setName("线程2");
t2.start();
}
}
2.4比较创建线程的两种方式:
开发中: 优先选择 ==》 实现Runnable接口的方式
选择的原因:
1.实现的方式没有类的单继承性的局限性
2.实现的方式更适合来处理多个线程有共享数据的情况。
联系: public class Thread implements Runnable
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
举例 :比如卖票,有几个窗口就有几个线程。
继承Thread类,票数必须要用static静态来表示,让票数处于共享,几个线程共用同一个票数。
而实现Runnable接口就不需要,天生就是共享数据,不过都有线程安全问题。
比如重票,错票,或者可能没按顺序卖票,
只是显示到页面的时候没及时显示出来 ,实际是按顺序的。
2.5测试Thread中的常用方法
2.5.1 方法:
- start():启动当前线程;调用当前线程的run()
- run():通常需要重写Thread类中的此方法,
将创建的线程要执行的操作声明在此方法中 - currentThread():静态方法,返回执行当前代码的线程
- getName():获取当前线程的名字
- setName():设置当前线程的名字或者根据构造器来改名字
- yield():释放当前cpu的执行权 但谁能拿到还是不确定
- join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,
直到线程b完全执行完以后,线程a才结束阻塞状态。 - stop():已过时。当执行此方法时,强制结束当前线程。
- sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。
在指定的millitime毫秒时间内,当前线程是阻塞状态 - isAlive():判断当前线程是否存活
2.5.2 线程的优先级:
-
MAX_ PRIORITY: 10
MIN_ PRIORITY: 1
NORM_ PRIORITY: 5 默认优先级 -
如何获取和设置当前线程的优先级
(1)getPriority():获取线程的优先级
(2)setPriority(int p):设置线程的优先级
说明:
高优先级的线程要抢占低优先级线程cpu的执行权。
但是只是从概率上讲,高优先级的线程高概率的情况下被执行。
并不意味着只有当高优先级的线程执行完以后,低优先级的线程才执行。
2.5.3 举例:
class HelloThread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
// try {
// sleep(10);//毫秒 1 秒=1000 毫秒
// } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName() + ":" + getPriority() + ":" + i);
//Thread.currentThread().可以省略
}
// if (i % 20 == 0){ yield(); }
}
}
public HelloThread(String name){ super(name); }
}
public class ThreadMethodTest {
public static void main(String[] args) {
HelloThread h1 = new HelloThread("Thread:1");
// h1.setName("线程一");
//设置分线程的优先级
h1.setPriority(Thread.MAX_PRIORITY);
h1.start();
// 给主线程命名
Thread.currentThread().setName("主线程");
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
if (i % 2 ==0){
System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
}
// if (i == 20) {
// try {
// h1.join();
// } catch (InterruptedException e) {e.printStackTrace();}
// }
}
System.out.println(h1.isAlive());
}
}
2.5.4 异常
Error:java:无效的行发行版:1.9
装了1.8的JDK 在 1.9 版本的环境跑 肯定抛错
3.线程的生命周期
3.1 生命周期
JDK中用Thread.State类定义了线程的几种状态
要想实现多线程,必须在主线程中创建新的线程对象。
Java语言使用Thread类及其子类的对象来表示线程,
在它的一个完整的生命周期中通常要经历如下的五种状态:
-
新建: 当一个Thread类或其子类的对象被声明并创建时,
新生的线程对象处于新建状态 -
就绪: 处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,
此时它已具备了运行的条件,只是没分配到CPU资源 -
运行: 当就绪的线程被调度并获得CPU资源时,便进入运行状态,
run()方法定义了线程的操作和功能 -
阻塞: 在某种特殊情况下,被人为挂起或执行输入输出操作时,
让出CPU并临时中止自己的执行,进入阻塞状态 -
死亡: 线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束
3.2 图示
4.线程的同步(重点)
4.1 问题的引入:
多个线程执行的不确定性引起执行结果的不稳定
4.1.1 举例:
创建三个窗口卖票,总票数为100张【使用实现Runnable的方式】
问题 :
卖票过程中,出现了重票、错票–>出现了线程的安全问题
问题出现的原因:
当某个线程操作车票的过程中,尚未操作完成时,其他线程参与进来,也操作车票。
如何解决:
当一个线程a在操作ticket的时候,其他线程不能参与进来。
直到线程a操作完ticket时,其他线程才可以开始操作ticket。
这种情况即使线程a出现了阻塞,也不能被改变。
总结: 在Java中,我们通过同步机制,来解决线程的安全问题。
4.2 方式一: 同步代码块
4.2.1 代码:
synchronized(同步监视器){ //需要被同步的代码 }
4.2.2 说明:
- 操作共享数据的代码,即为需要被同步的代码
–>不能包含代码多了,也不能包含代码少了。 - 共享数据:多个线程共同操作的变量。比如:ticket就是共享数据
- 同步监视器,俗称:锁。 任何一个类的对象,都可以充当锁。
要求: 多个线程必须要共用同一把锁。(唯一的)
补充:
在实现Runnable接口创建多线程的方式中,我们可以考虑使用this充当同步监视器。
4.2.3 举例1:
使用同步代码块解决实现Runnable接口的线程安全问题
class Window1 implements Runnable {
private int ticket = 100;
// Object obj = new Object();
// Dog dog = new Dog();
@Override
public void run() {
while (true){
//方式一:
synchronized (this){
//此时的this:唯一的window1的对象 当前对象
// 方式二: synchronized (dog) {
if (ticket > 0) {
try {
Thread.sleep(100);
//sleep 阻塞状态 线程二就进来的概率极大增加
//会出现-1 0等等的概率大大增加
} catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
} else { break; }
}
}
}
}
public class WindowTest1 {
public static void main(String[] args) {
Window1 w = new Window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
class Dog{}
注意:
如果synchronized(同步监视器){ } 写在while(true)外面,
那么就只有一个随机的线程进去,并且这个线程执行到完毕,
不会有其他的线程进去。
4.2.4 举例2:
使用同步代码块解决继承Thread类的方式的线程安全问题
说明:
在继承Thread类创建多线程的方式中,
慎用this充当同步监视器,
考虑使用当前类充当同步监视器。
class Window2 extends Thread{
private static int ticket = 100;
private static Object obj = new Object();
@Override
public void run() {
while (true){
// synchronized (obj) {
//上面是正确的 下面是第二种方式
synchronized (Window2.class){
//类也是对象 Window2.class也是唯一的,只会加载一次
// 下面是错的:this代表着t1,t2,t3三个对象
//synchronized (this){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + ":卖票,票号为:" + ticket);
ticket--;
} else { break; }
}
}
}
}
public class WindowTest2 {
public static void main(String[] args) {
Window2 t1 = new Window2();
Window2 t2 = new Window2();
Window2 t3 = new Window2();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
4.2 方式二: 同步方法
4.2.1 说明
如果操作共享数据的代码完整的声明在一个方法中,
我们不妨将此方法声明同步的。
4.2.2 举例1:
使用同步方法解决实现Runnable接口的线程安全问题
class Window3 implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
show();
}
}
public synchronized void show(){//同步监视器:this
// synchronized (this) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
}
// } 没有break 记得手动停止
}
}
public class WindowTest3 {
public static void main(String[] args) {
Window3 w = new Window3();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
4.2.3 举例2:
使用同步方法处理继承Thread类的方式中的线程安全问题
class Window4 extends Thread {
private static int ticket = 100;
@Override
public void run() {
while (true) { show(); }
}
public static synchronized void show(){//同步监视器:Window4.class 唯一的
//同步监视器: t1,t2,t3 不是唯一的this 这边 不能用synchronized 可以再加个static
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) { e.printStackTrace();}
System.out.println(Thread.currentThread().getName() + ":卖票,票号为:" + ticket);
ticket--;
}
// 没有break 记得手动停止
}
}
public class WindowTest4 {
public static void main(String[] args) {
Window4 t1 = new Window4();
Window4 t2 = new Window4();
Window4 t3 = new Window4();
t1.setName("窗口1");
t2.setName("窗口2");
t3.setName("窗口3");
t1.start();
t2.start();
t3.start();
}
}
4.2.4 关于同步方法的总结
- 同步方法仍然涉及到同步监视器,只是不需要我们显式的声明。
- 非静态的同步方法,同步监视器是: this
静态的同步方法,同步监视器(即锁)是:当前类本身
4.3 同步的好坏
好处:
同步的方式,解决了线程的安全问题。
坏处(局限):
操作同步代码时,只能有一个线程参与,其他线程等待。
相当于是一个单线程的过程,效率低。