【博学谷学习记录】超强总结，用心分享丨大数据超神之路(五)：多线程aa1.1 相关概念2. 线程的创建与启动3. Thread类4.线程的生命周期5 线程安全

112 阅读 0 评论 74 点赞

我是靠谱客的博主听话水壶，最近开发中收集的这篇文章主要介绍【博学谷学习记录】超强总结，用心分享丨大数据超神之路(五)：多线程aa1.1 相关概念2. 线程的创建与启动3. Thread类4.线程的生命周期5 线程安全，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

1.1 相关概念
- 1.1.1 并发与并行
- 1.1.2 进程与线程
- 1.1.3 多线程的优点机应用场景
- 1.1.4 线程调度
2. 线程的创建与启动
- 2.1 继承Thread类
- 2.2 实现Runnable接口
- 2.3 两种创建线程方式比较
- 2.4 匿名内部类对象创建线程
3. Thread类
- 3.1 构造方法
- 3.2 线程使用基础方法
- 3.3 线程控制常用方法
4.线程的生命周期
- 4.1 传统线程模型的五种线程状态
- 4.2 JDK定义的六种线程状态（了解）
5 线程安全
- 5.1 线程安全问题引出
- - 5.1.1 局部变量不能共享
  - 5.1.2 不同对象的实例变量不共享
  - 5.1.3 静态变量是共享的
  - 5.1.4 同一个对象的实例变量共享
- 5.2 原因分析
- 5.3 线程安全问题解决方式
- 5.4 锁对象选择
- - 5.4.1 同步方法的锁对象问题

1.1 相关概念

1.1.1 并发与并行

并行（parallel）：指多个事件任务在同一时刻发生（同时发生）。指在同一时刻，有多条指令在多个处理器上同时执行。单核CPU同一时刻只能处理一条指令，所以单核CPU做不到并行处理。
并发（concurrency）：指两个或多个事件在同一个微小的时间段内发生。指在同一个时刻只能有一条指令执行，但多个进程的指令被快速轮换执行，使得在宏观上具有多个进程同时执行的效果。程序并发执行可以在有限条件下，充分利用CPU资源，这是我们研究的重点。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU 系统中，每一时刻只能有一个程序执行，即微观上这些程序是分时的交替运行，只不过是给人的感觉是同时运行，那是因为分时交替运行的时间是非常短的。

而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理，线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU核心时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

单核CPU：只能并发

多核CPU：并行+并发
现代多核处理器实际上是在适当的任务上进行并行处理，并且只要软件编写正确即可。具有多个线程并不能保证能利用多个内核。例如，线程可能受到共享资源争用的限制-例如，它们都需要访问一块内存。他们还可能争用共享的I / O资源，例如磁盘访问或网络访问。
例子：

并行：多项工作一起执行，之后再汇总，例如：泡方便面，电水壶烧水，一边撕调料倒入桶中
并发：同一时刻多个线程在访问同一个资源，多个线程对一个点，例如：春运抢票、电商秒杀…

1.1.2 进程与线程

程序：为了完成某个任务和功能，选择一种编程语言编写的一组指令的集合。
软件：1个或多个应用程序+相关的素材和资源文件等构成一个软件系统。
进程：进程是对一个程序运行过程（创建-运行-消亡）的描述，系统会为每个运行的程序建立一个进程，并为进程分配独立的系统资源，比如内存空间等资源。
线程：线程是进程中的一个执行单元，负责完成执行当前程序的任务，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。多线程使得程序可以并发执行，充分利用CPU资源。

面试题：进程是操作系统调度和分配资源的最小单位，线程是CPU调度的最小单位。不同的进程之间是不共享内存的。进程之间的数据交换和通信的成本是很高。不同的线程是共享同一个进程的内存的。当然不同的线程也有自己独立的内存空间。对于方法区，堆中中的同一个对象的内存，线程之间是可以共享的，但是栈的局部变量永远是独立的。
每个应用程序的运行都是一个进程

我们可以再电脑底部任务栏，右键----->打开任务管理器,可以查看当前任务的进程：
在这里插入图片描述
一个应用程序的多次运行，就是多个进程

1.1.3 多线程的优点机应用场景

主要优点：
- 充分利用CPU空闲时间片，用尽可能短的时间完成用户的请求。也就是使程序的响应速度更快。
应用场景：
- 多任务处理。多个用户请求服务器，服务端程序可以开启多个线程分别处理每个用户的请求，互不影响。
- 单个大任务处理。下载一个大文件，可以开启多个线程一起下载，减少整体下载时间。

1.1.4 线程调度

指CPU资源如何分配给不同的线程。常见的两种线程调度方式：

分时调度

所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度

优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java采用的是抢占式调度方式。
- 抢占式调度详解
  
  大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，”感觉这些软件好像在同一时刻运行着“。
  
  实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。
  其实，多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。

2. 线程的创建与启动

java虚拟机是支持多线程的，当运行Java程序时，至少已经有一个线程了，那就是main线程。那么如何创建和启动一个新的线程呢？创建线程的简单方式有两种：

2.1 继承Thread类

通过继承Thread类来创建并启动多线程的步骤:

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程
自定义线程类：

public class MyThread extends Thread {
	//定义指定线程名称的构造方法
	public MyThread(String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	/**
	 * 重写run方法，完成该线程执行的逻辑
	 */
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}

测试类：创建线程对象并启动线程

public class Demo01 {
	public static void main(String[] args) {
		//创建自定义线程对象
		MyThread mt = new MyThread("新的线程！");
		//开启新线程
		mt.start();
		//在主方法中执行for循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
	}
}

多线程执行情况分析
在这里插入图片描述
注意事项：

手动调用run方法不是启动线程的方式，只是普通方法调用。
start方法启动线程后，run方法会由JVM调用执行。
不要重复启动同一个线程，否则抛出异常IllegalThreadStateException
不要使用Junit单元测试多线程，不支持，主线程结束后会调用System.exit()直接退出JVM;

2.2 实现Runnable接口

Java有单继承的限制，当我们无法继承Thread类时，那么该如何做呢？在核心类库中提供了Runnable接口，我们可以实现Runnable接口，重写run()方法，然后再通过Thread类的对象代理启动和执行我们的线程体run()方法。
通过实现Runnable接口创建线程并启动的步骤:

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

自定义线程任务类：

  public class MyRunnable implements Runnable{
  	@Override  
      public void run() {
          for (int i = 0; i < 20; i++) {
          	System.out.println(Thread.currentThread().getName()+" "+i);         
  		}       
  	}    
  }

测试类：创建线程对象并启动线程

  public class Demo {
      public static void main(String[] args) {
          //创建自定义类对象  线程任务对象
          MyRunnable mr = new MyRunnable();
          //创建线程对象
          Thread t = new Thread(mr, "小强");
          t.start();
          for (int i = 0; i < 20; i++) {
              System.out.println("旺财 " + i);
          }
      }
  }

2.3 两种创建线程方式比较

Thread类本身也是实现了Runnable接口的，run方法都来自Runnable接口，run方法也是真正要执行的线程任务。
```
public class Thread implements Runnable {}
```
因为Java类是单继承的，所以继承Thread的方式有单继承的局限性，但是使用上更简单一些。
实现Runnable接口的方式，避免了单继承的局限性，并且可以使多个线程对象共享一个Runnable实现类（线程任务类）对象，从而方便在多线程任务执行时共享数据。

2.4 匿名内部类对象创建线程

匿名内部类对象的方式创建线程，并不是一种新的创建线程的方式，只是在线程任务只需执行一次的情况下，我们无需单独创建线程类，可以采用匿名对象的方式：

new Thread("新的线程！"){
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(getName()+"：正在执行！"+i);
		}
	}
}.start();

new Thread(new Runnable(){
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"：" + i);
        }
    }
}).start();

java中有规定，如果实现的接口本身没有抛异常，那么实现类是不能抛的。

3. Thread类

3.1 构造方法

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

3.2 线程使用基础方法

public void run() :此线程要执行的任务在此处定义代码。
public String getName() :获取当前线程名称。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
public final boolean isAlive()：测试线程是否处于活动状态。如果线程已经启动且尚未终止，则为活动状态。
public final int getPriority() ：返回线程优先级
public final void setPriority(int newPriority) ：改变线程的优先级
- 每个线程都有一定的优先级，优先级高的线程将获得较多的执行机会。每个线程默认的优先级都与创建它的父线程具有相同的优先级。Thread类提供了setPriority(int newPriority)和getPriority()方法类设置和获取线程的优先级，其中setPriority方法需要一个整数，并且范围在[1,10]之间，通常推荐设置Thread类的三个优先级常量：
- MAX_PRIORITY（10）：最高优先级
- MIN _PRIORITY （1）：最低优先级
- NORM_PRIORITY （5）：普通优先级，默认情况下main线程具有普通优先级。

public static void main(String[] args) {
    Thread t = new Thread(){
        public void run(){
            System.out.println(getName() + "的优先级：" + getPriority());
        }
    };
    t.setPriority(Thread.MAX_PRIORITY);
    t.start();

    System.out.println(Thread.currentThread().getName() +"的优先级：" + Thread.currentThread().getPriority());
}

3.3 线程控制常用方法

public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public static void sleep(long millis) :线程睡眠，使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static void yield()：线程礼让，yield只是让当前线程暂时失去执行权，让系统的线程调度器重新调度一次，希望优先级与当前线程相同或更高的其他线程能够获得执行机会，但是这个不能保证，完全有可能的情况是，当某个线程调用了yield方法暂停之后，线程调度器又将其调度出来重新执行。
void join() ：加入线程，当前线程中加入一个新线程，等待加入的线程终止后再继续执行当前线程。

void join(long millis) ：等待该线程终止的时间最长为 millis 毫秒。如果millis时间到，将不再等待。

void join(long millis, int nanos) ：等待该线程终止的时间最长为 millis 毫秒 + nanos 纳秒。
public final void stop()：强迫线程停止执行。该方法具有不安全性，已被弃用，最好不要使用。
- 调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作，包括在 catch 或 finally 语句中的，并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获)，因此可能会导致一些清理性的工作的得不到完成，如文件，数据库等的关闭。
- 调用 stop() 方法会立即释放该线程所持有的所有的锁，导致数据得不到同步，出现数据不一致的问题。
public void interrupt()：中断线程，实际上是给线程打上一个中断的标记，并不会真正使线程停止执行。
public boolean isInterrupted()：检查线程是否中断，实际上检查线程是否有中断标记，如果有自己编写代码使此线程停止。
public void setDaemon(boolean on)：将线程设置为守护线程或用户线程。必须在线程启动之前设置，否则会报IllegalThreadStateException异常。
- 守护线程，主要为其他线程服务，当程序中没有非守护线程执行时，守护线程也将终止执行。JVM垃圾回收器也是守护线程。
public boolean isDaemon()：检查当前线程是否为守护线程。

代码：倒计时

public static void main(String[] args) {
		for (int i = 10; i>=0; i--) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("新年快乐！");
	}

守护线程

public class TestThread {
	public static void main(String[] args) {
		MyDaemon m = new MyDaemon();
		m.setDaemon(true);
		m.start();

		for (int i = 1; i <= 100; i++) {
			System.out.println("main:" + i);
		}
	}
}

class MyDaemon extends Thread {
	public void run() {
		while (true) {
			System.out.println("我一直守护者你...");
			try {
				Thread.sleep(1);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

4.线程的生命周期

4.1 传统线程模型的五种线程状态

传统线程模型中把线程的生命周期描述为五种状态：新建（New）、就绪（Runnable）、运行（Running）、阻塞（Blocked）、死亡（Dead）。CPU需要在多条线程之间切换，于是线程状态会多次在运行、阻塞、就绪之间切换。

在这里插入图片描述

1. 新建

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状。此时它和其他Java对象一样，仅仅由JVM为其分配了内存，并初始化了实例变量的值。此时的线程对象并没有任何线程的动态特征，程序也不会执行它的线程体run()。

2. 就绪

但是当线程对象调用了start()方法之后，线程就从新建状态转为就绪状态。这时线程并未执行，只是具备了运行的条件，还需要获取CPU资源后才能执行。

3. 运行

如果处于就绪状态的线程获得了CPU资源，开始执行run()方法的线程体代码，则该线程处于运行状态。如果计算机只有一个CPU，在任何时刻只有一个线程处于运行状态，如果计算机有多个处理器，将会有多个线程并行(Parallel)执行。

当然，美好的时光总是短暂的，而且CPU讲究雨露均沾。对于抢占式策略的系统而言，系统会给每个可执行的线程一个小时间段来处理任务，当该时间用完，系统会剥夺该线程所占用的资源，让其回到就绪状态等待下一次被调度。此时其他线程将获得执行机会，而在选择下一个线程时，系统会适当考虑线程的优先级。

4. 阻塞

当在运行过程中的线程遇到某些特殊情况时，线程会临时放弃CPU资源，不再执行，即进入阻塞状态。比如：线程调用了sleep()方法，会主动放弃所占用的CPU资源。

5. 死亡

线程完成任务结束或意外终止后，线程就处于死亡状态。

4.2 JDK定义的六种线程状态（了解）

在java.lang.Thread类内部定义了一个枚举类用来描述线程的六种状态：

public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

跟传统线程模型中的线程状态不同的是：

枚举类中没有区分就绪和运行状态，而是定义成了一种状态Runnable。
- 因为对于Java对象来说，只能标记为可运行，至于什么时候运行，不是JVM来控制的了，是OS来进行调度的，而且时间非常短暂，因此对于Java对象的状态来说，无法区分。只能我们人为的进行想象和理解。
传统模型中的阻塞状态在枚举类的定义中又细分为了三种状态的：BLOCKED、WAITING、TIMED_WAITING。
- BLOCKED：是指互有竞争关系的几个线程，其中一个线程占有锁对象时，其他线程只能等待锁。只有获得锁对象的线程才能有执行机会。
- TIMED_WAITING：当前线程执行过程中遇到Thread类的sleep或join，Object类的wait，LockSupport类的park方法，并且在调用这些方法时，设置了时间，那么当前线程会进入TIMED_WAITING，直到时间到，或被中断。
- WAITING：当前线程执行过程中遇到遇到Object类的wait，Thread类的join，LockSupport类的park方法，并且在调用这些方法时，没有指定时间，那么当前线程会进入WAITING状态，直到被唤醒。
  - 通过Object类的wait进入WAITING状态的要有Object的notify/notifyAll唤醒；
  - 通过Condition的await进入WAITING状态的要有Conditon的signal方法唤醒；
  - 通过LockSupport类的park方法进入WAITING状态的要有LockSupport类的unpark方法唤醒
  - 通过Thread类的join进入WAITING状态，只有调用join方法的线程对象结束才能让当前线程恢复；
说明：当从WAITING或TIMED_WAITING恢复到Runnable状态时，如果发现当前线程没有得到监视器锁，那么会立刻转入BLOCKED状态。

在这里插入图片描述

5 线程安全

当我们使用多个线程访问同一资源（可以是同一个变量、同一个文件、同一条记录等）的时候，但是如果多个线程中对资源有读和写的操作，就会出现前后数据不一致问题，这就是线程安全问题。

案例：三个窗口售卖共100张火车票。

5.1 线程安全问题引出

5.1.1 局部变量不能共享

public class SaleTicketDemo1 {
	public static void main(String[] args) {
		Window w1 = new Window();
		Window w2 = new Window();
		Window w3 = new Window();
		
		w1.start();
		w2.start();
		w3.start();
	}
}
class Window extends Thread{
	public void run(){
	// 局部变量
		int total = 100;
		while(total>0) {
			System.out.println(getName() + "卖出一张票，剩余:" + --total);
		}
	}
}

结果：发现卖出300张票。

问题：局部变量是每次调用方法都是独立的，那么每个线程的run()的total是独立的，不是共享数据。

5.1.2 不同对象的实例变量不共享

public class SaleTicketDemo2 {
	public static void main(String[] args) {
		TicketSaleThread t1 = new TicketSaleThread();
		TicketSaleThread t2 = new TicketSaleThread();
		TicketSaleThread t3 = new TicketSaleThread();
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class TicketSaleThread extends Thread{
// 实例变量
	private int total = 10;
	public void run(){
		while(total>0) {
			System.out.println(getName() + "卖出一张票，剩余:" + --total);
		}
	}
}

结果：发现卖出300张票。

问题：不同的实例对象的实例变量是独立的。

5.1.3 静态变量是共享的

public class SaleTicketDemo3 {
	public static void main(String[] args) {
		TicketThread t1 = new TicketThread();
		TicketThread t2 = new TicketThread();
		TicketThread t3 = new TicketThread();
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class TicketThread extends Thread{
	private static int total = 10;
	public void run(){
		while(total>0) {
			try {
				Thread.sleep(10);//加入这个，使得问题暴露的更明显
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(getName() + "卖出一张票，剩余:" + --total);
		}
	}
}

结果：发现卖出近100张票。

问题（1）：但是有重复票或负数票问题。

原因：线程安全问题

问题（2）：如果要考虑有两场电影，各卖100张票，这场卖完就没票了，新的线程对象也没有票卖了

原因：TicketThread类的静态变量，是所有TicketThread类的对象共享。本来成员变量就是run方法共享的数据，再用static不合适。

5.1.4 同一个对象的实例变量共享

public class SaleTicketDemo3 {
	public static void main(String[] args) {
		TicketSaleRunnable tr = new TicketSaleRunnable();
		Thread t1 = new Thread(tr,"窗口一");
		Thread t2 = new Thread(tr,"窗口一");
		Thread t3 = new Thread(tr,"窗口一");
		
		t1.start();
		t2.start();
		t3.start();
	}
}
class TicketSaleRunnable implements Runnable{
	private int total = 10;
	public void run(){
		while(total>0) {
			try {
				Thread.sleep(10);//加入这个，使得问题暴露的更明显
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName() + "卖出一张票，剩余:" + --total);
		}
	}
}

结果：发现卖出近100张票。

问题：但是有重复票或负数票问题。

原因：线程安全问题

5.2 原因分析

在这里插入图片描述
总结：线程安全问题的出现因为具备了以下条件

多线程执行
共享数据
多条语句操作共享数据

5.3 线程安全问题解决方式

上述线程安全问题的必备条件1和2是我们需要的，要解决只能从第三个点上想办法。要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了线程同步机制来解决。
在这里插入图片描述

同步即一步一步完成操作，第一步未完成不能进行下一步，相当单线程执行任务；
异步即几步操作可以互不干扰的执行，你做你的事，我做我的事，相当于多线程执行任务。
多线程中的同步机制，可以理解为把有线程安全问题代码，变成同步执行的代码，或者看成一个不能拆分的整体，一个线程执行完这整块代码后，下一个线程才能再来执行
Java中常使用关键字synchronized 来实现同步机制：
同步方法：synchronized 关键字直接修饰方法，表示同一时刻只有一个线程能进入这个方法，其他线程在外面等着。

public synchronized void method(){
    可能会产生线程安全问题的代码
}

同步代码块：synchronized 关键字可以用于某个区块前面，表示只对这个区块的资源实行互斥访问。
格式:

synchronized(同步锁){
     需要同步操作的代码
}

5.4 锁对象选择

同步锁对象：

锁对象可以是任意类型。
多个线程对象要使用同一把锁。

5.4.1 同步方法的锁对象问题

（1）静态方法：当前类的Class对象

（2）非静态方法：this

最后

以上就是听话水壶为你收集整理的【博学谷学习记录】超强总结，用心分享丨大数据超神之路(五)：多线程aa1.1 相关概念2. 线程的创建与启动3. Thread类4.线程的生命周期5 线程安全的全部内容，希望文章能够帮你解决【博学谷学习记录】超强总结，用心分享丨大数据超神之路(五)：多线程aa1.1 相关概念2. 线程的创建与启动3. Thread类4.线程的生命周期5 线程安全所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：大数据GODLIKE
浏览次数：112 次浏览
发布日期：2023-08-03 02:30:04
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_22_f3_13__7__10_1.html

【博学谷学习记录】超强总结，用心分享丨大数据超神之路(五)：多线程aa1.1 相关概念2. 线程的创建与启动3. Thread类4.线程的生命周期5 线程安全

概述

文章目录

1.1 相关概念

1.1.1 并发与并行

1.1.2 进程与线程

1.1.3 多线程的优点机应用场景

1.1.4 线程调度

2. 线程的创建与启动

2.1 继承Thread类

2.2 实现Runnable接口

2.3 两种创建线程方式比较

2.4 匿名内部类对象创建线程

3. Thread类

3.1 构造方法

3.2 线程使用基础方法

3.3 线程控制常用方法

4.线程的生命周期

4.1 传统线程模型的五种线程状态

4.2 JDK定义的六种线程状态（了解）

5 线程安全

5.1 线程安全问题引出

5.1.1 局部变量不能共享

5.1.2 不同对象的实例变量不共享

5.1.3 静态变量是共享的

5.1.4 同一个对象的实例变量共享

5.2 原因分析

5.3 线程安全问题解决方式

5.4 锁对象选择

5.4.1 同步方法的锁对象问题

最后

评论列表共有 0 条评论

发表评论取消回复

【博学谷学习记录】超强总结，用心分享丨大数据超神之路(五)：多线程aa1.1 相关概念2. 线程的创建与启动3. Thread类4.线程的生命周期5 线程安全

概述

文章目录

1.1 相关概念

1.1.1 并发与并行

1.1.2 进程与线程

1.1.3 多线程的优点机应用场景

1.1.4 线程调度

2. 线程的创建与启动

2.1 继承Thread类

2.2 实现Runnable接口

2.3 两种创建线程方式比较

2.4 匿名内部类对象创建线程

3. Thread类

3.1 构造方法

3.2 线程使用基础方法

3.3 线程控制常用方法

4.线程的生命周期

4.1 传统线程模型的五种线程状态

4.2 JDK定义的六种线程状态（了解）

5 线程安全

5.1 线程安全问题引出

5.1.1 局部变量不能共享

5.1.2 不同对象的实例变量不共享

5.1.3 静态变量是共享的

5.1.4 同一个对象的实例变量共享

5.2 原因分析

5.3 线程安全问题解决方式

5.4 锁对象选择

5.4.1 同步方法的锁对象问题

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复