多线程知识汇总，看这一遍就够了

最新推荐文章于 2024-04-29 13:37:28 发布
最新推荐文章于 2024-04-29 13:37:28 发布
阅读量275 收藏 5
点赞数 1
分类专栏： javaSE 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39331255/article/details/108481343
版权

01. 程序(programm)

概念：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，一般存储在硬盘中。

02. 进程(process)

概念：程序的一次执行过程，或是正在运行的一个程序。
说明：进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域，存储在内存中。

03. 线程(thread)

概念：进程可进一步细化为线程，是一个程序内部的一条独立的执行路径。
说明：线程作为调度和执行的单位，每个线程拥独立的运行栈和程序计数器(pc)，线程切换的开销小。
一个进程可以有多个子任务，每个线程都可以独立的完成其中一个任务。在各个子任务之间，没有什么依赖关系，可以单独执行。
在这里插入图片描述“多任务”：指操作系统能同时运行多个进程（程序）。如window7系统可以同时运行写字板程序、画图程序、WORD、EXCEL等。

进程和线程的关系：

 	一个进程中，可以有多条线程；但是一个进程中，至少有一条线程
    一个进程中的所有线程，共享同一个进程中的资源

并行与并发的理解

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。
并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事
在这里插入图片描述

一个Java应用程序java.exe，其实至少三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

创建多线程的两种方法

方式一：继承Thread类的方式：

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类的run() --> 将此线程执行的操作声明在run()中
  3. 创建Thread类的子类的对象
  4. 通过此对象调用start()：①启动当前线程 ② 调用当前线程的run()
class A extends Thread{
	public void run(){  // 重写Thread类的run方法
		for(int i=1;i<=30;i++){
			System.out.println("A..."+i);
			
		}
	}
}

class B extends Thread{
	
	public void run(){
        for(int i=1;i<=30;i++){
			System.out.println("B<<<"+i);
			
		}
	}
}
public class Test2 {
	public static void main(String[] args) {
		A a = new A();
		B b = new B();
		
	/*	a.run();  // 方法调用，不能实现并发的效果
		b.run();
		*/
		a.start();  // 启动线程A  ------> 线程启动后，自动会调用run方法
		b.start();  // 启动线程B
	}
}

方式二：实现Runnable接口的方式：

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法：run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
  5. 通过Thread类的对象调用start()
class X implements Runnable{
	@Override
	public void run() {
       for(int i=1;i<=30;i++){
			System.out.println("X..."+i);
			
		}
	}
}
class Y implements Runnable{
	@Override
	public void run() {
        for(int i=1;i<=30;i++){
			System.out.println("Y###"+i);
			
		}
	}
}
public class Test3 {
	  public static void main(String[] args) {
		  X x = new X();
		  Y y = new Y();
		  Thread t1 = new Thread(x);
		  Thread t2 = new Thread(y);
		  t1.start();
		  t2.start();    
	}
}

两种方式的对比：

开发中：优先选择：实现Runnable接口的方式
原因：1. 实现的方式没类的单继承性的局限性
2. 实现的方式更适合来处理多个线程共享数据的情况。
相同点：两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
目前两种方式，要想启动线程，都是调用的Thread类中的start()。

Thread类中的常用的方法:

new Thread(Runnable r,String name) 初始化线程的名字

  1. start():启动当前线程；调用当前线程的run()
  2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
  3. currentThread():静态方法，返回执行当前代码的线程
  4. getName():获取当前线程的名字
  5. setName():设置当前线程的名字
  6. yield():释放当前cpu的执行权，进入就绪状态，Thread.yield();，此处是Thread工具类调用静态方法。
  7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态。
  8. stop():已过时。当执行此方法时，强制结束当前线程。
  9. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
  10. isAlive():判断当前线程是否存活
public class Demo03_Thread的常见方法 {
	public static void main(String[] args) {
		X x = new X();
		x.setName("线程1"); // 设置线程名
		
		Thread t = new Thread(new Y(),"线程2");  // 在创建Thread时，分配线程名字
		x.start();
		t.start();
	}
}

class X extends Thread{
    public void run() {
		for(int i=1;i<=30;i++){
			
			System.out.println("X###"+i+Thread.currentThread().getName());  // getName() 获取线程名    在没有设置线程名字时，获取到的线程名为Thread-0,1,2
		}
	}
}

class Y implements Runnable{

public void run() {
		for(int i=1;i<=30;i++){
			
	System.out.println("Y<<<>>>"+i+Thread.currentThread().getName());
			//Thread.currentThread() 获得当前正在运行的线程对象
		}
	}
}

线程的优先级：

MAX_PRIORITY：10
MIN _PRIORITY：1
NORM_PRIORITY：5 -->默认优先级

如何获取和设置当前线程的优先级：
getPriority():获取线程的优先级
setPriority(int p):设置线程的优先级

说明：高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只当高优先级的线程执行完以后，低优先级的线程才执行。

线程的分类

一种是守护线程（后台线程），一种是用户线程。
守护线程只有在别的线程运行的时候才有意义。当所有前台线程都运行完成后，无论后台线程是否运行完成都要结束。（注意：是在一段时间内结束，并不会立即结束）
setDaemon(boolean on)设置守护线程
必须在启动线程之前（调用start方法之前）调用setDaemon（true）方法，才可以把该线程设置为后台线程。

线程的生命周期

在这里插入图片描述

停止线程的方式

（1）线程对象的stop方法（过时）
（2）定义标识的方法。

多线程产生的数据共享问题

我们通过同步机制，来解决线程的安全问题。

方式一：同步代码块

synchronized(同步监视器){
//需要被同步的代码

}
说明：1.操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
2.共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
要求：多个线程必须要共用同一把锁。

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。

关于同步方法的总结：

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
  2. 非静态的同步方法，同步监视器是：this
    静态的同步方法，同步监视器是：当前类本身

方式三：Lock锁 — JDK5.0新增

  1. 面试题：synchronized 与 Lock的异同？

相同：二者都可以解决线程安全问题
不同：synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动的启动同步（lock()，同时结束同步也需要手动的实现（unlock()）

使用的优先顺序：

Lock —> 同步代码块（已经进入了方法体，分配了相应资源 ) —> 同步方法（在方法体之外)

使用同步机制将单例模式中的懒汉式改写为线程安全的。

class Bank{

    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
        //方式一：效率稍差
//        synchronized (Bank.class) {
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if(instance == null){

            synchronized (Bank.class) {
                if(instance == null){

                    instance = new Bank();
                }

            }
        }
        return instance;
    }

}

1.死锁的理解：

不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁

2.说明：

* 1出现死锁后，不会出现异常，不会出现提示，只是所的线程都处于阻塞状态，无法继续
* 2我们使用同步时，要避免出现死锁

1.线程通信涉及到的三个方法：

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个（按wait的先后顺序唤醒）。
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。

2.说明：

1.wait()，notify()，notifyAll()三个方法必须使用在同步代码块或同步方法中。
2.wait()，notify()，notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
否则，会出现IllegalMonitorStateException异常
3.wait()，notify()，notifyAll()三个方法是定义在java.lang.Object类中。

3.面试题：

面试题：sleep() 和 wait()的异同？

1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep() , Object类中声明wait()
2）调用的要求不同：sleep()可以在任何需要的场景下调用。 wait()必须使用在同步代码块或同步方法中
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。

释放锁和不释放锁的操作

在这里插入图片描述
在这里插入图片描述

线程池介绍

系统启动一个新线程的成本是比较高的。因为涉及到和操作系统的交互。在这种情况下使用线程池可以很好的提高性能。尤其是当程序中需要创建大量生存期很短暂的线程时，更应该考虑使用线程池。

没有线程池的状态：
当我们使用一条线程的时候，先将线程对象创建出来，启动线程，在运行过程中，可能能完成任务，也可能会在中途被任务内容中断掉，任务还没有完成。
即使是能够正常完成，线程对象就结束了，就变成了垃圾对象，需要被垃圾回收器回收
如果在系统中，大量的任务都是小任务，任务消耗时间较短、线程对象的创建和消亡耗费的时间比较多，结果：大部分的时间都浪费在了线程对象的创建和死亡上。
如果任务本身破坏力比较大，可能会把线程对象结束掉，就无法继续完成任务。

有线程池的状态：
在没有任务的时候，先把线程对象准备好，存储到一个容器中，一旦有任务来的时候，就不需要创建对象，而是直接将对象获取出来执行任务
如果任务破坏力较小，任务可以直接完成，这个线程对象不会进入死亡状态，而是被容器回收，继续活跃。
如果任务破坏力较大，任务会把线程搞死，线程池会继续提供下一个线程，继续完成这个任务。

与数据库连接池类似，线程池在系统启动时即创建大量空闲的线程，程序将一个Runnable对象传给线程池，线程池就会启动一条线程来执行该对象的run方法。当run方法执行结束后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个Runnable对象的run方法。
除此之外，使用线程池可以有效地控制系统中并发线程的数量，当系统中包含大量并发线程时，会导致系统性能剧烈下降，甚至导致JVM崩溃，而线程池的最大线程数可以控制系统中并发线程数目不超过线程池最大线程数目。
JDK1.5以前，必须手动实现自己的线程池，从JDK1.5开始，Java内建支持线程池。

线程池创建方式

 JDK1.5提供了一个Executors工厂类来产生线程池，该工厂类包含如下几个静态工厂方法来创建线程池：

newCachedThreadPool()：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool(int n)：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newSingleThreadExecutor():创建一个只有单线程的线程池，相当于newFixedThreadPool(1)

newScheduledThreadPool(int corePoolSize):创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。参数表示池中保存的线程数。
newSingleThreadScheduledExecutor()：创建只有一条线程的线程池，它可以在指定延迟后执行线程任务。

以上五个方法的前三个方法返回一个ExecutorService对象，该对象代表一个线程池，它可以执行Runnable或Callable(后面介绍)对象所代表的线程。而后两个方法返回一个ScheduledExecutorService线程池，它是ExecutorService的子类，它可以指定延迟后执行线程任务。

ExecutorService

ExecutorService代表尽快执行线程的线程池（只要线程池中有空闲线程立即执行线程任务）， 程序只要将一个Runnable对象或Callable对象提交给该线程池即可，该线程池就会尽快执行该任务。

ExecutorService里提供了三个方法：

Future<?> submit(Runnable task):
Future<?> 代表Runnable任务的返回值，因为run方法没有返回值，所以返回值为null。
Future submit(Callable task):
将Callable对象传给submit，Future是 call()方法调用后的返回值。

当用完一个线程池后，应该调用关闭线程池的方法。

shutdown():调用这个方法后，线程池将不会再接受新任务，但原有的任务会继续执行，直到执行完成.
shutdownNow():调用这个方法关闭线程池，没有执行完成的任务会暂停。

使用线程池的好处：

1.提高响应速度（减少了创建新线程的时间）
2.降低资源消耗（重复利用线程池中线程，不需要每次都创建）
3.便于线程管理
corePoolSize：核心池的大小
maximumPoolSize：最大线程数
keepAliveTime：线程没任务时最多保持多长时间后会终止

Callable接口

Callable接口是对Runnable接口的增强，提供了一个call()方法，作为线程的执行体。但call()方法比run()方法功能更强大。
call（）方法可以有返回值
call（）方法可以抛出异常
使用FutureTask包装Callable对象，用来获得call方法的返回值。

示例代码

class B implements Callable<Integer>{// 泛型限制 call方法的返回值类型
	public Integer call() throws Exception { 
		int i=0;
		for(;i<100;i++){
			System.out.println("callable..."+i);	
			Thread.sleep(200);
		}
		return i;
	}  
}
public class Test3 {
    
	    public static void main(String[] args) throws Exception {	
	    	B b = new B();
	    	FutureTask<Integer> task = new FutureTask<Integer>(b);
	    	new Thread(task).start();
	    	int x = task.get();  // 获得返回值
	    	System.out.println(x+"<<<<"); 
		}
}

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大？

  1. call()可以返回值的。
  2. call()可以抛出异常，被外面的操作捕获，获取异常的信息
  3. Callable是支持泛型的

单例模式

饿汉式

public class Demo01_单例模式_饿汉式 {
	
	public static void main(String[] args) {
		A a1 = A.getInstance();
		A a2 = A.getInstance();
		System.out.println(a1==a2);
	}
}

class A{
	private static A a = new A();  // 直接创建对象——饿汉式	
	private A(){  // 私有构造方法
	}
	
	public static A getInstance(){
		return a;
	}
}

懒汉式

private static Single1 s ;
	private Single1() {}
	
	public static Single1 getSingle1() {
		if(s==null) {
			synchronized (Single1.class) {
				if(s==null) {
					s = new Single1();
				}
			}
		}
		return s;
	}

老汉式

public class Demo03_单例模式_老汉式 {

	public static void main(String[] args) {
		
		C c1 = C.c;
		C c2 = C.c;
		
		System.out.println(c1==c2);
	}
}

class C{
	
	public final static C c = new C();
	
	private C(){
	}
}

垃圾回收（GC）

Java语言中，内存回收的任务由Java虚拟机来担当，而不是由Java程序来负责。在程序的运行时环境中，Java虚拟机提供了一个系统级的垃圾回收器线程，它负责自动回收那些无用对象所占用的内存，这种内存回收的过程被称为垃圾回收（Garbage Collection）

垃圾回收具有以下优点：

把程序员从复杂的内存追踪、监测和释放等工作中解放出来，减轻程序员进行内存管理的负担。
防止系统内存被非法释放，从而使系统更加健壮和稳定。

垃圾回收特点：

只有当对象不再被程序中的任何引用变量引用时，它的内存才可能被回收。
程序无法迫使垃圾回收器立即执行垃圾回收操作。
当垃圾回收器将要回收无用对象的内存时，先调用该对象的finalize()方法，该方法有可能使对象复活，导致垃圾回收器取消回收该对象的内存。

public class Demo01_垃圾回收 {
	public static void main(String[] args){
		User u1 = new User();   // 栈区的u1 指向堆区的对象
		u1 = new User();        // u1重写指向了堆区中的另外一个对象，原来指向的对象就没有引用指向它了，就变成了垃圾
		System.gc();  // 这个方法的含义是督促JVM进行垃圾回收工作，但不是强制。
	}
}

class User{
	private int id;
	private String name;
	private int age;
	
	public User() {
		super();
	}
	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	protected void finalize() throws Throwable {
		System.out.println("这个方法会在垃圾回收时被调用——回收前");
	}
}

线程相关类 ThreadLocal

ThreadLocal是什么呢？其实ThreadLocal并非是一个线程的本地实现版本，它并不是一个Thread，而是threadlocalvariable(线程局部变量)。也许把它命名为ThreadLocalVar更加合适。线程局部变量(ThreadLocal)其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是Java中一种较为特殊的线程绑定机制，每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。

private ThreadLocal tl = new ThreadLocal();
//tl.set(“xxx”); // 向ThreadLocal中存值
//tl.get(); // 取出ThreadLocal中的值

简单来说，每个线程往ThreadLocal存放数据，只供自己使用，其他线程访问不到。

package demo0910;

import java.util.Locale;

/**
 * @creat 2020-09-09-21:40
 */
public class Test2 {
    static ThreadLocal<Object> local = new ThreadLocal<>();
    public static void main(String[] args) {
        Thread thread = new Thread(new ss());
        thread.start();

        Thread thread1 = new Thread(new dd());
        thread1.start();
    }
}
class ss implements Runnable{

    @Override
    public void run() {
        Test2.local.set("aaa");
        System.out.println(Test2.local.get());
    }
}
class dd implements Runnable{

    @Override
    public void run() {
        Object o = Test2.local.get();
        System.out.println(o);
    }
}
五块兰州拉面
关注
专栏目录
《Windows核心编程》若干知识点实战应用分享
dvlinker的技术专栏
01-21 3万+
《Windows核心编程》若干知识点应用实践分享，希望大家能够仔细研读，在提升理论知识水平的同时，也能有效地提高分析解决问题的技能。
多线程并行执行，汇总结果
01-18
多线程并行执行，汇总结果、多线程并行执行，汇总结果
多线程基础
weixin_52754604的博客
09-13 210
程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储中，可以理解为程序是包含静态代码的文件。例如：浏览器软件、音乐播放器软件等软件的安装目录和文件。
多线程的知识点
qq_62086657的博客
05-27 412
多线程、进程、synchronize、生产者与消费者模式、wait（）方法、sleep（）方法、线程生命周期、yield（）方法、jion（）方法、notify（）方法、线程同步与互斥、锁
多线程知识点总结
Apple_Boy的博客
09-07 1638
文章目录进程和线程线程的状态及生命周期多线程实现的两种方式终止线程线程的优先级线程同步死锁yield与join方法的区别 进程和线程 进程： 程序在执行过程中分配和管理资源的基本单位，是一个动态概念，竞争计算机系统资源的基本单位。 线程： 是进程的一个执行单元，是进程内部的调度实体；比进程更小的独立运行的基本单位；线程也被称为轻量级进程 。 一个进程可以包含一个或多个线程，一个线程就是一个程序内部...
Java 多线程入门大全
贼老猪
10-10 1360
接触多线程已经不少时间了,也做了不少事情,但是一直觉得用起来不那么顺手,在debug的时候,往往会比较担心在同步上出什么问题,想起"程序员最怕的是自己写的代码"这句话,觉得真是不假.  终于有一天,我觉得是时候把这个问题弄清楚了,所以,我就在网上找相关的内容看,结果竟然是找不到在我这个阶段应该看的,不是太简单,就是一笔带过,不知所云.  废了九牛二虎之力,终于差不多弄清楚了,其中有不少误区,以前认
多线程相关知识点~~面试技巧
ronnie_rocket的博客
06-12 255
个人认为，学习，内容越多、越杂的知识，越需要进行深刻的总结，这样才能记忆深刻，将知识变成自己的。这篇文章主要是对多线程的问题进行总结的，因此罗列了40个多线程的问题。 这些多线程的问题，有些来源于各大网站、有些来源于自己的思考。可能有些问题网上有、可能有些问题对应的答案也有、也可能有些各位网友也都看过，但是本文写作的重心就是所有的问题都会按照自己的理解回答一遍，不会去看网上的答案，因此可能有些问题...
Linux C++ 多线程实战一——多线程排序
PurpleDream的博客
04-14 3200
    由于最近在学习C++从底层(指针，对象模型，内存管理)再到网络socket编程，多线程编程，数据库编程等方面知识，需要从Java慢慢的迁移过来。这是以前学习Java的学习路线，所以就把原来Java的做的项目全部用C++重新实现一遍。1. 多线程基础    这个可以看我的博客，里面都有详细的介绍以及如何使用linux C++多线程编程，参考如下：    Linux C++ 多线程编程基础(汇...
Python效率之王之多进程和多线程详解_python 多线程宠物实力
最新发布
m0_61072747的博客
04-29 254
对于IO-bound任务，使用多线程可以提高性能对于IO-bound任务，使用多进程也可以提高性能，但是开销往往比使用多线程要高Python GIL意味着在Python程序的任意给定时间内只能执行线程对于CPU bound任务，使用多线程实际会降低性能对于CPU bound任务，使用多进程可以提高性能巫师真的很棒！很久很久以前，在一个遥远的星系里……一个聪明而强大的巫师住在一个偏僻的小村庄里。我们叫他邓布利多吧。
算法、常用数据结构、文件资料、多线程和XML解析 资料汇总
04-06
### 知识点一：集合（Sets） #### Set 集合 - **特性**：`Set` 是一种不允许重复元素的数据结构。...这些知识点覆盖了 Java 中集合（Set 和 Map）、数组、多线程以及 XML 解析的基本概念和技术细节。
多线程相关知识整理
zhouym_的博客
05-10 649
进程 先来了解下什么是进程 进程：指正在运行的程序，例如：QQ,微信，浏览器等等 进程有前台进程，后台进程 一个进程可以有一条线程，也可以有多条线程 线程 线程：具有完成独立任务的一条执行路径 public class Thread extends Object implements Runnable 线程是程序中的执行线程。Java虚拟机允许应用程序并发的运行多个执行线程 每个线程都有一个...
多线程-汇总
前后端分离，人不分离！
10-13 459
百度百科：多线程，是指从软件或者硬件上实现多个线程并发执行的技术。
多线程知识
一个IT菜鸟的自白
07-24 1051
多线程在笔试面试中经常出现，下面列出一些公司的多线程笔试面试题。首先是一些概念性的问答题，这些是多线程的基础知识，经常出现在面试中的第一轮面试（我参加2011年腾讯研究院实习生招聘时就被问到了几个概念性题目）。然后是一些选择题，这些一般在笔试时出现，虽然不是太难，但如果在选择题上花费大多时间无疑会对后面的编程题造成影响，因此必须迅速的解决掉。最后是综合题即难一些的问答题或是编程题。这种题目当然是最
多线程知识点（详解）
weixin_45969382的博客
09-25 474
谈谈对程序、进程、线程的理解 程序(program):是为了完成特性任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process):是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程:有它自身的产生、存在和消亡的过程。(如:运行中的QQ,运行中的MP3播放器;程序是静态的，进程是动态的;进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域)。 线程(thread):一个线程是进程的一个顺序执行流。 1)若一个进程同一时间并执行多个线程，就是支持多线程的
多线程知识梳理
wzk646795873的博客
04-08 389
概述：关于并发编程问题的梳理总结,含线程池、并发控制锁、并发容器和队列同步器等基础知识点。1、如何停止一个线程？（1）使用volatile变量终止正常运行的线程+抛异常法/Return法。（2）组合使用interrupt方法与interruptted/isinterrupted方法终止正在运行的线程++抛异常法/Return法。（3）使用interrupt方法终止正在阻塞中的线程。2、何为线程安全...
多线程知识点整理
qq_37141187的博客
07-24 220
多线程知识点整理
Java多线程完全解析：概念、状态与同步机制
"Java中的多线程你只要看这一篇就够了" 在Java编程中，多线程是一个核心概念，它允许程序同时执行多个任务，从而更有效地利用CPU资源。本文将深入探讨Java中的多线程相关知识，包括线程状态、同步机制、线程创建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值