随笔- 1 文章- 0 评论- 0 阅读- 24

多线程的理解与线程池

多线程

多线程是Java提供的一种强大的功能，可以充分利用CPU资源并提高程序的执行效率。

主要有一下好处：

提高程序的响应性
使代码看起来更加简洁易懂
可以创建多个线程，利用多个cpu进行，提高性能优势

1. 进程与线程

1.1. 进程

进程是操作系统资源分配的基本单位，是操作系统中的最小单位。通过进程可以创建程序的应用

1.2. 线程

线程是进程中的最小单位，一个进程中至少有一个主线程，可以有多个子线程，并且所有的线程可以同时运行，称之为多线程状态。

2. 并发与并行

2.1. 并发

指两个或多个事件事件同一时间内进行间隔发生，有可能交替发生，不一定同时发生。如图：两个队列在同一个咖啡机上接咖啡

2.2. 并行

指两个或多个事件同时发生，在同一时刻上同时运行。如图：两个队列在两台咖啡机上接咖啡，互不影响。

3.自定义线程

3.1. 继承Thread类

//继承（extends）Thread类
public ExtendsThread extends Thread{
    
    //重写run方法
    public void run () {
        
    }
}

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

优点：继承的方式简单，写法简单，重写run方法，直接就可以进行调用
缺点：由于Java只可以进行单继承，所以不能在继承其他的thread类，所以扩展时较困难。

3.2. Runnable接口

//实现Runnable接口（implements）连接
public ImpThread implements Runnable{
    
    //重写run方法
    public void run () {
        
    }
}

public static void main(String[] args){
    //创建线程
    ExtendsThread et = new ExtendsThread();
    Thread t1 = new Thread(et);
    //启动线程
    t1.start();
}

优点：

可以共享资源，多个线程可以共享一个Runnable接口。
提高灵活度，可以实现继承的同时，还可以实现接口
提高代码的可维护性和可读性

3.3. run方法调用和start调用的区别

run方法是定义在线程类中，作为自定义线程，需要重写run方法，如果直接通过main主线程调用，就和调用普通的对象方法是一样的，并不会让线程单独启动。

start方法是定义在Thread类中的，通过Start方法，jvm虚拟机会自动的调用run方法，执行线程任务，所以该种方式是能够实现多线程的方式。

4.线程调度

4.1 setPriority设置优先级

更改线程的优先级。最低1级，最高10级，默认5级

	//创建线程
	Thread thread1 = new Thread() ;
 	//设置线程的优先级
	thread1.setPriority(10);
	//输出线程的优先级数
    System.out.println(thread1.getPriority());
	//调用线程
    thread1.start();

4.2 sleep 睡眠

可以让当前线程进行休眠状态，通过毫秒来设置

public class SleepTest extends Thread {
    public void run() {
        try{
            //进行休眠一秒
            Thread.sleep(1000);
        }catch(InterruptedException e){
            throw new RuntimeException(e);
        }
        
        System.out.println("一秒后进行打印！");
    }
}

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

4.3 join

让一条线程，强行插入到正在运行的线程中，并等待该线程运行结束后再次运行

public class JoinTest extends Thread {
    public void run() {
        for(int i = 0;i < 10;i++){
            System.out.println("强行插入进行打印！");
        }
        
    }
}

public static void main(String[] args){
    //创建线程
    JoinTest jt = new JoinTest();
    
   	for(int i=0;i<20;i++){
        //打印主线程
        System.out.println(Thread.currentThread().getName() + "=" + i);
        //但i=10的时候，强行插入，打印子线程
        if(i==10){
            try{
                jt.join();//强行插入执行，其他线程全部等待
            } catch (InterruptedException e){
                    throw newRuntimeException(e);
            }
        }
    }
}

4.4. yield礼让线程

线程礼让，暂停当前正在执行的线程对象，让其他线程运行，但是不保证一定会礼让。

public static void main(String[] args){
	for (int i = 0; i < 10; i++) {         
	System.out.println(Thread.currentThread().getName() + "=" + i);
            if(i == 5) {
                Thread.yield();//让出cpu，让其他线程先执行
			}
	}
}

5.线程状态

5.1 线程状态的概述

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。

、

我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几个状态呢，新建与被终止还是很容易理解的，我们就研究一下线程从Runnable（可运行）状态与非运行状态之间的转换问题。

5.2 等待与唤醒

Object.wait(): 调用线程对象的wait()方法可以使当前线程进入等待状态，等待其他线程调用相同对象的notify()方法来唤醒它。

Object.notify(): 调用同一对象的notify()方法可以唤醒在这个对象上等待的某个线程。

public class Demo1_wait {
    public static void main(String[] args) throws InterruptedException{

        new Thread(() -> {
            try{
                System.out.println("等待线程。。。");

                synchronized (""){
                    "".wait();//让执行的线程进行等待
                }
                System.out.println("over");
            }catch (Exception e){}
        }).start();

        Thread.sleep(3000);

        new Thread(() -> {
            try {
                synchronized (""){
                    System.out.println("唤醒");
                    "".notify();//唤醒进入等待中的线程
                }
            }catch (Exception e){}
        }).start();
    }
}

6. JMM

6.1 JMM的概述

JMM（Java Memory Model）是Java内存模型的缩写，是一种规范，定义了Java程序在多线程环境下的内存访问行为。Java内存模型定义了线程如何与主存中的共享变量进行交互，以及线程之间如何进行通信。

JMM的一些关键特性和规则包括：

可见性：JMM保证一个线程对共享变量的修改对其他线程是可见的。当一个线程修改了共享变量的值，JMM会确保其他线程能够立即看到最新的值。
顺序性：JMM保证线程按照程序的顺序来执行，即保证程序的串行语义。
原子性：JMM确保对一个共享变量的读写操作具有原子性。
顺序一致性：JMM对于单个线程的执行结果提供了顺序一致性的保证。即一个线程的执行结果必须与其他线程按照固定的顺序看到的执行结果是一致的。

6.1 volatile关键字的概述

volatile是Java关键字之一，它可以用来修饰变量。

volatile修饰的变量具有以下特点：

可见性：当一个线程修改了被volatile修饰的变量的值，其他线程能够立即看到最新的值，而不会使用线程自己的缓存值。
volatile不保证原子性。

6.2 volatile关键字的工作原理

vt线程从主内存读取到数据放到对应的工作内存中
将主内存的flag的值更改为true，但是工作内存的falg值没有进行更新，还是false
当vt线程将flag值修改为true，并传回主内存的时候，失效其他线程对此变量副本
main线程再次对flag进行操作的时候线程会从主内存读取最新的值，放入到工作内存中

public class VolatileThread extends Thread {
    
	// 定义成员变量（将falg用volatile关键字进行修饰）
	private boolean volatile flag = false ;
	public boolean isFlag() { 
        return flag;
    }
	@Override
	public void run() {
    	try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
        
	// 将flag的值更改为true
	this.flag = true ;
	System.out.println("flag=" + flag);
	}
}


public class VolatileThreadTest {// 测试类
	public static void main(String[] args) {
        
		// 创建VolatileThread线程对象
		VolatileThread volatileThread = new VolatileThread() ;
		volatileThread.start();
        
		// 进行死循环
		while(true) {
            //判断flag的值
			if(volatileThread.isFlag()) {
			System.out.println("执行了");
			}
		}
	}
}

7.原子性

7.1 原子性的概述

所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行。

7.2 volatile原子性测试

// 定义一个int类型的变量
private volatile int count = 0 ;

小结：在多线程环境下，volatile关键字可以保证共享数据的可见性，但是并不能保证对数据操作的原子性

（在多线程环境下volatile修饰的变量也是线程不安全的）。

在多线程环境下，要保证数据的安全性，我们还需要使用锁机制。

volatile的使用场景

开关控制：利用可见性特点，控制某一段代码执行或者关闭
多个线程操作共享变量，但是是有一个线程对其进行写操作，其他的线程都是可读

7.3 原子类CAS机制

概述：

CAS的全称是： Compare And Swap(比较再交换); 是现代CPU广泛支持的一种对内存中的共享数据进行操作的一种特殊指令。CAS可以将read-modify-check-write转换为原子操作，这个原子操作直接由处理器保证。

CAS机制当中使用了3个基本操作数：内存地址V，旧的预期值A，要修改的新值B。

举例：

在内存地址V当中，存储着值为10的变量。
此时线程1想要把变量的值增加1。对线程1来说，旧的预期值A=10，要修改的新值B=11。
在线程1要提交更新之前，另一个线程2抢先一步，把内存地址V中的变量值率先更新成了11。
线程1开始提交更新，首先进行A和地址V的实际值比较（Compare），发现A不等于V的实际值，提交失败
. 线程1重新获取内存地址V的当前值，并重新计算想要修改的新值。此时对线程1来说，A=11，B=12。这个重新尝试的过程被称为自旋。
这一次比较幸运，没有其他线程改变地址V的值。线程1进行Compare，发现A和地址V的实际值是相等的。
线程1进行SWAP，把地址V的值替换为B，也就是12。

7.4 CAS与Synchronized：乐观锁，悲观锁。

CAS和Synchronized都可以保证多线程环境下共享数据的安全性。那么他们两者有什么区别？

Synchronized是从悲观的角度出发（悲观锁）总是假设最坏的情况：

每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。因此Synchronized我们也将其称之为悲观锁。jdk中的ReentrantLock也是一种悲观锁。性能较差！！

CAS是从乐观的角度出发:

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断

一下在此期间别人有没有去更新这个数据。

CAS这种机制我们也可以将其称之为乐观锁。综合性能较好！

8.并发包

8.1 ConcurrentHashMap

为什么要使用ConcurrentHashMap：

HashMap线程不安全，会导致数据错乱
使用线程安全的Hashtable效率低下

为了保证线程安全，可以使用Hashtable。注意：线程中加入了计时

公有、静态的集合：

public class Const {
	public static Hashtable<String,String> map = new Hashtable<>();
}

线程，向map中写入数据：

public void run() {
	long start = System.currentTimeMillis();
	for (int i = 0; i < 500000; i++) {
		Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
	}
	long end = System.currentTimeMillis();
	System.out.println(this.getName() + " 结束！用时：" + (end - start) + " 毫秒");
}

测试类

public class Demo {
	public static void main(String[] args) throws InterruptedException {
		Thread1A a1 = new Thread1A();
		Thread1A a2 = new Thread1A();
		a1.setName("线程1-");
		a2.setName("线程2-");
		a1.start();
		a2.start();
        //休息10秒，确保两个线程执行完毕
        Thread.sleep(1000 * 5);
		//打印集合大小
		System.out.println("Map大小：" + Const.map.size());
	}
}

****ConcurrentHashMap

公有，静态的集合

public class Const {
	public static ConcurrentHashMap<String,String> map = new ConcurrentHashMap<>();
}

线程，向map中写入数据：

public void run() {
	long start = System.currentTimeMillis();
	for (int i = 0; i < 500000; i++) {
        Const.map.put(this.getName() + (i + 1), this.getName() + i + 1);
	}
	long end = System.currentTimeMillis();
	System.out.println(this.getName() + " 结束！用时：" + (end - start) + " 毫秒");
}

测试类

public class Demo {
	public static void main(String[] args) throws InterruptedException {
		Thread1A a1 = new Thread1A();
        Thread1A a2 = new Thread1A();
		a1.setName("线程1-");
		a2.setName("线程2-");
		a1.start();
		a2.start();
		//休息10秒，确保两个线程执行完毕
		Thread.sleep(1000 * 5);
		//打印集合大小
		System.out.println("Map大小：" + Const.map.size());
	}
}

ConcurrentHashMap仍能保证结果正确，而且提高了效率。

8.2 CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作，再执行自己。

CountDownLatch构造方法:

public CountDownLatch(int count)// 初始化一个指定计数器的CountDownLatch对象

CountDownLatch重要方法:

public void await() throws InterruptedException// 让当前线程等待
public void countDown() // 计数器进行减1

实例

制作线程1

public class ThreadA extends Thread {
	private CountDownLatch down ;
	public ThreadA(CountDownLatch down) {
		this.down = down;
	}
	@Override
	public void run() {
		System.out.println("A");
		try {
			down.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("C");
	}
}

制作线程2

public class ThreadB extends Thread {
	private CountDownLatch down ;
	public ThreadB(CountDownLatch down) {
		this.down = down;
	}
	@Override
	public void run() {
		System.out.println("B");
	down.countDown();
	}
}

制作测试类

public class Demo {
	public static void main(String[] args) {
		CountDownLatch down = new CountDownLatch(1);//创建1个计数器
		new ThreadA(down).start();
		new ThreadB(down).start();
	}
}

执行结果

会保证按：A B C的顺序打印。

8.3 CyclicBarrier

概述

CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一=个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。

CyclicBarrier构造方法：

public CyclicBarrier(int parties, Runnable barrierAction)// 用于在线程到达屏障时，优先执行barrierAction，方便处理更复杂的业务场景

CyclicBarrier重要方法：

public int await()// 每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞

使用场景

使用场景：CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场景。

需求：使用两个线程读取2个文件中的数据，当两个文件中的数据都读取完毕以后，进行数据的汇总操作。

8.4 Semaphore

Semaphore（发信号）的主要作用是控制线程的并发数量。

synchronized可以起到"锁"的作用，但某个时间段内，只能有一个线程允许执行。

Semaphore可以设置同时允许几个线程执行。

Semaphore字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。

Semaphore构造方法：

public Semaphore(int permits) permits          //表示许可线程的数量
public Semaphore(int permits, boolean fair)    //fair 表示公平性，如果这个设为 true的话，下次执行的线程会是等待最久的线程

Semaphore重要方法：

public void acquire() throws InterruptedException   //表示获取许可
public void release() release() 					//表示释放许可

8.5 Exchanger

概述

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生产出来的数据传递给对方。

Exchanger构造方法：

public Exchanger()

Exchanger重要方法：

public V exchange(V x)

使用场景

使用场景：可以做数据校对工作

需求：比如我们需要将纸制银行流水通过人工的方式录入成电子银行流水。为了避免错误，采用AB岗两人进行录入，录入到两个文件中，系统需要加载这两个文件，并对两个文件数据进行校对，看看是否录入一致，

9.线程池方式

9.1 线程池的概念

线程池：其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

由于线程池中有很多操作都是与优化资源相关的，我们在这里就不多赘述。我们通过一张图来了解线程池的工作原理：

合理利用线程池能够带来三个好处：

降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

9.2 线程池的使用

Executors类中有个创建线程池的方法如下：

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)

获取到了一个线程池ExecutorService 对象，那么怎么使用呢，在这里定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行

Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤：

创建线程池对象。
创建Runnable接口子类对象。(task)
提交Runnable接口子类对象。(take task)
关闭线程池(一般不做)。

Runnable实现类代码：

public class MyRunnable implements Runnable {
	@Override
	public void run() {
		System.out.println("我要一个教练");
	try {
		Thread.sleep(2000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	System.out.println("教练来了： " + Thread.currentThread().getName());
	System.out.println("教我游泳,交完后，教练回到了游泳池");
	}
}

线程池测试类：

public class ThreadPoolDemo {
	public static void main(String[] args) {
		// 创建线程池对象
		ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
		// 创建Runnable实例对象
		MyRunnable r = new MyRunnable();
		//自己创建线程对象的方式
		// Thread t = new Thread(r);
		// t.start(); ---> 调用MyRunnable中的run()
		// 从线程池中获取线程对象,然后调用MyRunnable中的run()
		service.submit(r);
		// 再获取个线程对象，调用MyRunnable中的run()
		service.submit(r);
		service.submit(r);
		// 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
		// 将使用完的线程又归还到了线程池中
		// 关闭线程池
        //service.shutdown();
	}
}

Callable测试代码:

Future submit(Callable task) : 获取线程池中的某一个线程对象，并执行.

Future : 表示计算的结果.
V get() : 获取计算完成的结果。

public class ThreadPoolDemo2 {
	public static void main(String[] args) throws Exception {
		// 创建线程池对象
		ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
		// 创建Runnable实例对象
		Callable<Double> c = new Callable<Double>() {
			@Override
			public Double call() throws Exception {
			return Math.random();
			}
		};
        // 从线程池中获取线程对象,然后调用Callable中的call()
		Future<Double> f1 = service.submit(c);
		// Futur 调用get() 获取运算结果
		System.out.println(f1.get());
		Future<Double> f2 = service.submit(c);
		System.out.println(f2.get());
		Future<Double> f3 = service.submit(c);
		System.out.println(f3.get());
	}
}

10.死锁

10.1 什么是死锁

在多线程程序中,使用了多把锁,造成线程之间相互等待.程序不往下走了。

10.2 产生死锁的条件

1.有多把锁

2.有多个线程

3.有同步代码块嵌套

10.3 死锁代码

public class Demo05 {
	public static void main(String[] args) {
		MyRunnable mr = new MyRunnable();
		new Thread(mr).start();
		new Thread(mr).start();
	}
}
class MyRunnable implements Runnable {
	Object objA = new Object();
	Object objB = new Object();
	/*
	嵌套1 objA
	嵌套1 objB
	嵌套2 objB
	嵌套1 objA
	*/
	@Override
	public void run() {
		synchronized (objA) {
			System.out.println("嵌套1 objA");
			synchronized (objB) {// t2, objA, 拿不到B锁,等待
				System.out.println("嵌套1 objB");
			}
		}
			synchronized (objB) {
			System.out.println("嵌套2 objB");
			synchronized (objA) {// t1 , objB, 拿不到A锁,等待
				System.out.println("嵌套2 objA");
			}
		}
	}
}

注意:我们应该尽量避免死锁

posted @ 2023-07-18 08:42 兀念阅读(24) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 多线程基础

· 多线程基础知识点梳理

· java线程

· 4.深入理解 Java 多线程与并发编程

阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！

公告

昵称：兀念
园龄： 1年7个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

随笔档案

2023年7月(1)

阅读排行榜

1. 多线程的理解与线程池(24)

bky2305956559