Java笔记(多线程)

文章目录

  • 一、多线程
    • 1.程序,进程,线程
    • 2.并行和并发
    • 3.单核 CPU 和多核 CPU
    • 4.多线程优缺点和应用场景
    • 5.线程创建
      • 5.1.Thread
      • 5.2.Runnable
      • 5.3.继承和实现的区别
    • 6.优先级和常用方法
      • 6.1.优先级概述
      • 6.2.常用方法
      • 6.3.使用方式
    • 7.生命周期
    • 8.线程控制
      • 8.1.线程停止
      • 8.2.线程合并
      • 8.3.Yield
    • 9.线程同步
      • 9.1.概述
      • 9.2.不同步带来的问题
      • 9.3.解决方案
        • 9.3.1.方法锁
        • 9.3.2.语句块锁
      • 9.4.Synchronized
    • 10.Lock
      • 10.1.概述
      • 10.2.使用
      • 10.3.优缺点
    • 11.守护线程
    • 12.定时器任务
      • 12.1.概述
      • 12.2.使用

一、多线程

1.程序,进程,线程

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

2.并行和并发

  • 并发:同时发生
  • 并行:同时执行

3.单核 CPU 和多核 CPU

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

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

****背景:****以单核CPU为例,只使用单个线程先后完成多个任务(调用多个方 法),肯定比用多个线程来完成用的时间更短,为何仍需多线程呢?

多线程程序的优点

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

应用场景

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

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.生命周期

Java笔记(多线程)_第1张图片

8.线程控制

Java笔记(多线程)_第2张图片

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);
		}
	}
}

你可能感兴趣的:(java,笔记)