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为例，只使用单个线程先后完成多个任务（调用多个方 法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？
多线程程序的优点：
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和
应用场景：
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时
5.线程创建
- 线程创建有两种方式：
-
- 继承 Thread 类，并覆写 run 方法
- 实现 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);
}
}
}