多线程

最新推荐文章于 2022-10-30 16:00:07 发布

Geneartion_Z

最新推荐文章于 2022-10-30 16:00:07 发布

阅读量151

点赞数

分类专栏：后端文章标签：多线程并发编程

本文链接：https://blog.csdn.net/Geneartion_Z/article/details/113349746

版权

后端专栏收录该内容

29 篇文章 0 订阅

订阅专栏

1、线程概述

java线程

java线程内存模型跟CPU缓存模型类似，是基于CPU缓存模型来建立的，java线程内存模型是标准化的，屏蔽掉了底层不同计算机的区别

1、1 线程相关概念

进程（Process）
是计算机中的程序关于某数据集合上的一次运行活动，是操作系统将进行资源分配与调度的基本单位。【可以简单的理解为操作系统中运行的一个程序】

线程（thread）
是进程的一个执行单元
一个线程就是进程中的一个单一顺序的控制流，进程的一个执行分支。
进程是线程的容器，一个进程至少有一个线程，一个进程中也可以有多个线程。
在操作系统中，是以进程为单位分配资源，如虚拟存储空间，文件描述符等。
每个线程都有各自的线程栈，自己的寄存器环境自己得线程本地存储。

主线程与子线程
JVM启动时会创建一个主线程，该主线程负责执行main方法，主线程就是运行main方法的线程
java中的线程不是孤立的，线程之间也存在一些联系，如果在A线程中创建了B线程，称B线程为A线程的子线程，B为A的父线程

串行，并发与并行
串行（Sequential），任务A做完后再做任务B，逐个完成任务
并发（Concurrent），先做任务A，在等待A完成时做任务B，间隙完成
并行（Parallel），所有任务同时开始

软件角度：
并发可以提高处理效率
并行是一种更为严格/理想的并发
硬件角度：
如果是单核CPU，一个处理器一次只能执行一个线程，处理器可以使用时间片轮转技术，CPU的执行速度很快，可以在三个任务之间切换，感觉是三个线程在同时执行。
如果是多核CPU，可以为不同线程分配不同的CPU内核

1、2 线程的创建与启动

在java中，创建一个线程就是创建一个Thread类（子类）的对象
Thread类有两个常用的构造方法，对应了两种创建线程的方式

	Thread(){}			//定义Thread的子类
	Thread(Runnable){}	//定义一个Runnable接口的实现类

这两种方式没有本质的区别

1、3 线程的常用方法

currentThread()方法

Thread.currentThread()方法可以获得当前线程，返回值是在实际运行时的线程对象
java中任何一段代码都是执行在某个线程中的，执行当前代码的线程就是当前线程
同一段代码可能被不同的线程执行，因此当前线程是相对的，

public static void main(String[] args) {
	System.out.println("main方法的当前线程=" + Thread.currentThread().getName());//当前main方法的当前线程为main
	SubThread1 subThread1 = new SubThread1();//在main方法中调用其构造方法，当前线程也为main
	subThread1.start();//子线程启动，自己调用run方法，当前线程就为子线程
	subThread1.run();//在主线程中调用子线程的run方法，当前线程为main线程
	//在子线程的run方法中，如果有受检异常（编译时异常）需要处理，只能捕获不能抛出
}

setName()/getName()

设置/获取线程名称
通过设置线程名称，有助于程序调试，提高可读性，建议每个线程都设置名称

//new一个新的Thread对象
MyThread t1 = new MyThread();
t1.setName("t1");//用setName更改线程名称
Thread t2 = new Thread(t1);//创建对象时参数填入Runnable的实现类，Thread实现了Runnable接口，MyThread继承了Thread；
t2.start();//线程开始之后，实际调用的是t1线程的run方法。
/*
 @Override
 public void run() {
      if (target != null) {
          target.run();
      }
  }
*/

sleep(time)//单位是毫秒

Threed.sleep(millis);让当前线程休眠指定的毫秒数
当前线程指的是Thread.currentThread()返回的线程
通过sleep方法设置一个简单的计时器

public class SimpleTimer {
    public static void main(String[] args) {
        int remaining = 10;
        if(args.length>=1){
            remaining = Integer.parseInt(args[0]);
        }
        System.out.println("begin");
        while (remaining > 0){
            System.out.println(remaining);
            remaining -- ;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("end");
    }
}

isLive()

thread.isAlive()判断当前线程是否处于活动状态
活动状态就是线程已启动并且尚未终止。

getId()

thread.getId()可以获得线程的唯一标识
某个编号的线程运行结束后，该编号可能被后续的线程使用

yield()

静态方法，Thread.yield()：放弃当前的CPU资源。

setPriority()

thread.setPriority(num) ；设置线程的优先级
java线程的优先级取值范围是1~10，如果超出这个范围，会抛出异常 IllegalArgumentException

在操作系统中，线程可以划分优先级，越高的线程获得执行权的几率越大
线程优先级本质上只是给线程调度器一个提示信息，以便于调度器决定先调度哪些线程

注意：不能保证优先级高的线程先运行

*java优先级设置不当可能会导致某些线程永远无法得到运行，即产生了线程饥饿。

interrupt()

中断线程
调用interrupt()方法仅仅是在当前线程打一个停止标志，并不是真正停止

for(int i = 1;i<100 ;i++){
	if(this.isInterrupted){//判断是否为中断，来结束该线程
		return;
	}
}

isInterrupted()

返回线程的中断标志

setDaemon(true)

设置线程为守护线程
Java中的线程分用户线程和守护线程
守护线程是为其他线程提供服务的，例如GC垃圾回收器
守护线程不能单独运行，如果用户线程全部结束，守护线程也自动销毁，JVM会退出

1、4线程的生命周期

线程的生命周期就是线程对象的生老病死，即线程的状态
线程的状态图线程的生命周期可以通过getState()方法获得，是一个枚举类型，有这个取值

NEW

新建状态，创建线程对象，还没有调用start()

Runnable

READY准备状态可以被线程调度器进行调度
RUNNING状态表示该线程正在执行run()
Thread.yield()可以让RUNNING转变成READY

BLOCKED

阻塞状态。
线程发起阻塞的I/O操作，或者申请由其他线程占用的独占资源，线程会转换为BLOCKED阻塞状态
处于阻塞状态的线程不会占用CPU资源，当阻塞IO执行完，或者线程获得了其申请的资源就可以转换为RUNNABLE

WAITING

等待状态
线程执行了object.wait()或者thread.join()会把线程转换为WAITING等待状态。
执行object.notify()方法，或者加入的线程执行完毕，当前线程会转换为RUNNABLE状态

TIMED_WAITING

等待状态，处于该状态的线程不会无限的等待
如果线程没有在指定的时间范围内完成期望的操作，该线程会自动转换为RUNNABLE状态

TERMINAZTED

终止状态，线程结束

1、5 多线程编程的优势

提高系统的吞吐率(Throughout)

多线程编程可以是一个进程有多个并发(concurrent，即同时进行的)操作

可以提高响应性(Responsiveness)。

Web服务器会采用一些专门的线程负责用户的请求处理，缩短了用户的等待时间

充分利用多核(Multicore)处理器资源

可以充分利用CPU资源

1、5 多线程编程存在的风险

线程安全(Thread safe)问题

多线程共享数据时，如果没有采取正确的并发访问控制措施，就可能会产生数据一致性问题。
比如读取脏数据（过期的数据），丢是数据更新

线程活性问题(Thread liveness)问题

由于程序自身的缺陷或者由资源的稀缺性导致线程一直处于非RUNNABLE状态，这就是线程活性问题
比如：
1）死锁(Deadlock)：类似于鹬蚌相争
2）锁死(Lockout)：睡美人中的王子挂了
3）活锁(Livelock)：小猫一直咬自己的尾巴
4）饥饿（Starvation）：类似健壮的雏鸟总从母鸟中抢食物

上下文切换(Context Switch)

处理器从一个线程切换到到另一个线程需要性能消耗

可靠性

可能会由一个线程导致JVM意外终止，其他的线程也无法执行

2 线程安全问题

非线程安全主要是指多个线程对同一个对象的实例变量进行操作时，会出现值被更改，值不同步的情况
线程安全会表现为三个方面，原子性，可见性和有序性

2.1 原子性（共享变量）

原子(Atomic)就是不可分割的意思，原子操作的不可分割有两层含义
1）访问（读、写）某个共享变量的操作从其他线程来看，该操作要么已经执行完毕，要么尚未发生，即其他线程看不到该线程的中间结果
2）访问同一组共享变量的原子操作是不能够交错的
比如说：现实生活中从ATM取款，对用户来说要么取款成功，要么没拿到钱，相当于操作没有发生

java中有两种方式实现原子性

1、使用锁，锁具有排他性，可以保证共享变量再某一时刻只能被一个线程访问
2、使用CAS(Compare and Swap)指令直接在硬件(处理器和内存）层次实现，看做是硬件锁

//演示线程的原子性问题
public class Test{
	public static void main(String[] args){
		//启动两个线程,
		for(int i = 0;i < 2;i++){
			new Thread(new Runnable(){
				@Override
				public void run(){
				MyNum myNum = new MyNum();
					while(true){
						myNum.getNum();	//会发现两个线程同时读取到相同的数字
				   }
				}
			}).start();
		}
	}
	//读完了之后再自增，有可能还没自增呢，下一个线程又读到了该数值
	static class MyNum{		
		int num;
		public int getNum(){
			return num++;
		}
	}
	//在java中，提供了一个线程安全的AtomicInteger类，保证操作的原子性
	static class MyNum2{	
		AtomicInteger num = new AtomicInteger();
		public int getNum(){
			return num.getAndIncrem;
		}
	}
}