Java笔记(多线程)

最新推荐文章于 2024-05-18 16:42:38 发布

独行乡窝窝侠

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量920

点赞数 21

文章标签： java 笔记

本文链接：https://blog.csdn.net/m0_73783104/article/details/135830536

版权

一、多线程

1.程序，进程，线程

程序：一堆代码的封装，指的是我们保存在硬盘中的可执行文件，静态概念
进程：正在执行或等待执行的程序，在程序内存中处理，属于动态概念
线程：程序运行时，不同的执行分支
java 来说：当我们的程序开始执行时，也就是 main 方法开始执行，在栈内存开辟以 main 方法为栈底元素的栈帧此时，这个以 main 方法为栈底元素的链式栈帧调用，就称为主线程
CPU 时间片，把 CPU 5次的执行时间当做一个基本单位，称为一个时间片，然后给每个线程分配执行时间，这个是由操作系统来决定一般会根据优先级来进行发放
并发：同时发生
并行：同时执行
1 个 CPU 同一时间只能做一件事，所以没有办法并行执行，但是可以处理并发

2.并行和并发

并发：同时发生
并行：同时执行

3.单核 CPU 和多核 CPU

1 个 CPU 同一时间只能做一件事，所以没有办法并行执行，但是可以处理并发
单核 CPU 是假的多线程，因为一个时间单位内，只能执行一个线程的任务
多核 CPU 才能更好发挥多线程的效率

4.多线程优缺点和应用场景

****背景：****以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点：

提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
提高计算机系统CPU的利用率
改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和

应用场景：

程序需要同时执行两个或多个任务
程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
需要一些后台运行的程序时

5.线程创建

线程创建有两种方式：
1. 继承 Thread 类，并覆写 run 方法
2. 实现 Runnable 接口，并覆写 run 方法
启动线程只有一种方式，就是调用线程对象的 start 方法

5.1.Thread

public class Thread_01_Create {
	public static void main(String[] args) {
		// 创建线程对象，直接new即可
		Thread thread=new Processor1();
		// 线程启动
		thread.start();
		for (int i = 0; i < 5; i++) {
			System.out.println("main线程："+i);
		}
	}
}
// 继承 Thread 类的方法
class Processor1 extends Thread{
	@Override
	public void run() {//实现接口run()方法
		for (int i = 0; i < 5; i++) {
			System.out.println("测试线程:"+i);
		}
	}
}

5.2.Runnable

public class Thread_02_Create {
	public static void main(String[] args) {
		// 继承Thread类和实现Runnable 接口创建对象时会有所差别
		Thread thread=new Thread(new Processor2());
		// 启动线程
		thread.start();
		for (int i = 0; i < 5; i++) {
			System.out.println("main线程："+i);
		}
	}
}
// 实现 Runnable 接口的方式
class Processor2 implements Runnable{

	@Override
	public void run() {//都要实现run()方法
		for (int i = 0; i < 5; i++) {
			System.out.println("接口线程："+i);
		}
	}
}

5.3.继承和实现的区别

优先使用实现，保留类继承

6.优先级和常用方法

6.1.优先级概述

优先级：java中提供了 10 个优先级，分别是 1(min)~10(max)
Thread 中提供了 3 个常量，MIN_PRIORITY 代表 1，NORM_PRIORITY 代表 5 ，MAX_PRIORITY 代表 10
子类默认继承父类优先级，Thread 默认是 5

源码：

 /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

6.2.常用方法

//设置优先级
setPriority 
//获取优先级
getPriority 
//获取线程名称
getName 
//设置线程名字,如果不设置名字,默认为 Thread_0 开始,以此类推
setName 
//获取当前线程对象
static  currentThread  
//让当前线程进入睡眠状态,参数为毫秒
static sleep

6.3.使用方式

public class Thread_03_Priority {
	public static void main(String[] args) {
		Thread t1=new Processor3();
		Thread t2=new Processor3();
		// 设置线程名字,要在线程启动之前设置
		t1.setName("t1");
		t2.setName("t2");
		// 设置线程优先级 1(min)~10(max)
		t1.setPriority(1);
		t2.setPriority(10);
		// 想要调用线程一定要 启动线程
		t1.start();
		t2.start();
		try {
			// 静态方法，现在哪里就对谁生效，此时这个就对main方法生效
			// 因为最后都等于类名调用,所以main方法 最后执行完毕
			t1.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}
 class Processor3 extends Thread{
	@Override
	public void run() {
			for (int i = 0; i < 5; i++) {
				//currentThread() 获取当前线程对象
				//getName()获取对象名字
				System.out.println(Thread.currentThread().getName()+"-->"+i);
			}
	}
 }

public class Thread_04_Interrupt {
	public static void main(String[] args) {
		Thread thread=new Thread(new Processor4());
		// 不要忘记启动线程 start ！！！
		thread.start();
		try {
			thread.sleep(5000);
			// 5s后会打断thread线程，会抛出异常
			thread.interrupt();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class Processor4 implements Runnable{
	@Override
	public void run() {
		try {
			//写在Processor4中所以对Processor4生效
			Thread.sleep(10000);
			System.out.println("睡醒了");
		} catch (InterruptedException e) {
			e.printStackTrace();
			System.out.println("被叫醒");
		}
		System.out.println("执行结束");
	}
}

7.生命周期

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

8.线程控制

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

8.1.线程停止

public class Thread_05_Stop {
	public static void main(String[] args) {
		Processor5 p5=new Processor5();
		p5.start();
		try {
			Thread.sleep(3000);
			// 直接结束p5进程不推荐使用(有删除线)，可能会导致死锁
			//p5.stop();
			p5.run=false;
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
class Processor5 extends Thread{
	boolean run=true;
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			if(!run){
				return;
			}
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		System.out.println("测试线程结束");
	}
}

8.2.线程合并

public class Thread_06_Join {
	public static void main(String[] args) throws InterruptedException {
		Thread t1=new Thread(new Processor6());
		Thread t2=new Thread(new Processor6());
		t1.setName("t1");
		t2.setName("t2");
		t1.start();
		t2.start();
		// 把t1和main合并，就是把t1写到main线程中，t1执行完后main再执行
		//对t2没有影响
		t1.join();
		for (int i = 0; i <5; i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			Thread.sleep(1000);
		}
	}
}
class Processor6 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 5; i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

8.3.Yield

public class Thread_07_Yield {
	public static void main(String[] args) throws InterruptedException {
		Thread t1=new Thread(new Processor7());
		t1.setName("t1");
		t1.setPriority(5);
		Thread.currentThread().setPriority(5);
		t1.start();
		for (int i = 0; i <10; i++) {
			if(i%3==0){
				// yield() : 给 同优先级 让位 , 只有资源不够时才会进行让位
				Thread.yield();
			}
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}
class Processor7 implements Runnable{
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

9.线程同步

9.1.概述

*问题的提出*

多个线程执行的不确定性引起执行结果的不稳定

多个线程对账本的共享，会造成操作的不完整性，会破坏数据

线程同步 : 当多个线程同时操作一个数据的时候,为了保证数据的一致性和正确性,需要使用线程同步
线程同步是一种数据的安全机制
同步的原因 :
1 同步是指数据的同步,为了数据安全,必须等某个线程对数据操作完之后,再让其他线程进行操作
同步,可以理解为,把多线程在特定情况下改为单线程
2 同步条件
- 必须是多线程,必须有多并发的情况才有可能出现问题
- 多个线程有可能同时操作某一个数据的时候(同一个对象),尤其是修改操作,查询无所谓

9.2.不同步带来的问题

可能会出现多个线程抢占同一资源导致运行结果与实际不符

public class Thread_08_Synchronization {
	public static void main(String[] args) {
		Account account=new Account("1001",666);
		Thread t1=new Thread(new Processor8(account));
		Thread t2=new Thread(new Processor8(account));
		t1.start();
		t2.start();
	}
}
class Processor8 implements Runnable{
	Account account;
	@Override
	public void run() {
		account.withDraw(100);
		System.out.println(Thread.currentThread().getName()+"还剩："+account.getBalance());
	}
	public Processor8(Account account){
		this.account=account;
	}
}
// 实体类
class Account{//账户
	private String  actNO;//编号
	private double balance;//存款
    // 修改余额
	public void withDraw(double money){
		System.out.println(Thread.currentThread().getName());
		try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			balance=balance-money;	
	}
	public double getBalance() {
		return balance;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	public Account(String actNO, double balance) {
		super();
		this.actNO = actNO;
		this.balance = balance;
	}
	public Account() {
		super();
	}
}

9.3.解决方案

对修改余额的方法进行加锁处理，不让多个线程同时进入执行

9.3.1.方法锁

// 使用 synchornized 修饰符 修饰方法后，该方法只能有一个线程进入，其他线程必须等这个线程执行完后才能进入
public synchronized void withDraw(double money){
	System.out.println(Thread.currentThread().getName());
	try {
		Thread.sleep(1000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	balance=balance-money;
}

9.3.2.语句块锁

public void withDraw(double money){
	System.out.println(Thread.currentThread().getName());
	// 语句块锁，只需要锁住需要同步的代码即可，对方法内的其他代码不会同步
	synchronized (this) {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		balance=balance-money;
	}
}

9.4.Synchronized

访问一个加锁的成员方法/成员语句块锁时,该对象中所有加锁的成员方法及对象语句块锁,都会被锁定
访问一个加锁的静态方法/静态语句块锁时,该类中所有加锁的静态方法和静态语句块锁,都会被锁定
synchronized (对象) {} 对象语句块锁
synchronized (类名.class) {} 类语句块锁

10.Lock

10.1.概述

从 JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同

步锁对象来实现同步。同步锁使用Lock对象充当。
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象。
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

10.2.使用

	// 创建锁对象
	Lock lock=new ReentrantLock();
	public void withDraw(double money){
		System.out.println(Thread.currentThread().getName());
		// 开启锁，同步
		lock.lock();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		balance=balance-money;
		// 释放锁，结束同步
		lock.unlock();
	}

10.3.优缺点

Lock 是显式锁，需要手动关闭
并且 JVM 将花费时间较少的时间来完成线程调度，性能更好，并且还具备更好的扩展性

11.守护线程

每一个 main 主线程的开启，都会同时开启一个守护线程，来监听我们的正常程序执行
当没有其他线程执行时(除了守护线程之外的线程都不执行时)，守护线程终止，只要还有一个其他线程执行，守护线程都不会终止

public class Thread_10_Daemon {
	public static void main(String[] args) {
		Thread t1=new Thread(new Processor10());
		//设置守护线程
		t1.setDaemon(true);// 要在线程开始执行之前设置守护线程
		t1.start();
		for (int i = 0; i < 5; i++) {
			try {
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+"-->"+i);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}
class Processor10 implements Runnable{
	@Override
	public void run() {
		int i=1;
		while (true) {
			try {
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+"-->"+i++);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

12.定时器任务

12.1.概述

计划任务，只要有一个计划任务就会开启一个线程，进行计时监听，多久之后做什么事，就像闹钟一样，多久时候响
定时器相当于一个新的线程，不会影响到 main 的运行，就像闹钟一样，定了闹钟之后，手机依旧可以玩其他的东西，不会只监听一个闹钟
每个定时计划都需要一个全新的线程去监听

12.2.使用

public class Thread_11_Timer {
	public static void main(String[] args) {
		// 创建定时器
		Timer time=new Timer();
		// 开启定时器
		// 第一个参数：要做的事，TimerTask子类对象
		// 第二个参数：开始时间，传入毫秒代表多久之后开始运行，也可以传入Date对象
		// 第三个参数：间隔时间
		time.schedule(new LogTimerTask(), 3000,1000);// 开启新线程，不会影响到其他线程的运行
	}
}
class LogTimerTask extends TimerTask{
	@Override
	public void run() {
		// 要做的事
		for (int i = 0; i < 5; i++) {
			System.out.println(i);
		}
	}
}

独行乡窝窝侠

关注

21
点赞
踩
21

收藏

觉得还不错? 一键收藏
1
评论
Java笔记(多线程)

优先级：java中提供了 10 个优先级，分别是 1(min)~10(max)Thread 中提供了 3 个常量，MIN_PRIORITY 代表 1，NORM_PRIORITY 代表 5 ，MAX_PRIORITY 代表 10子类默认继承父类优先级，Thread 默认是 5/***//***//***/*问题的提出*多个线程执行的不确定性引起执行结果的不稳定多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
复制链接

扫一扫