学习笔记输出来源:拉勾教育Java就业急训营
修改时间:2021年1月6日
作者:pp_x
邮箱:pp_x12138@163.com
文章目录
多线程
程序和进程的概念
- 程序:数据结构 + 算法,主要指存放在硬盘上的可执行文件。(.exe)
- 进程:指正在运行中(在内存中)的程序
- 目前操作系统几乎都是支持多进程的,但是进程时重量级的,会消耗cpu和内存空间的资源,所以通常进程的数量比较局限
线程的概念
- 一个进程至少一个线程组成
- 线程是轻量级的
- 新建线程会共享所在进程的系统资源,因此目前主流的开发都是采用多线程。
- 多线程是采用时间片轮转法来进行多线程并发的,并发就是指宏观上并行,微观上串行的机制
线程的创建
Thread类的概念
java.lang.Thread
类代表线程,任何线程对象都是Thread类(子类)的实例。- Thread类是线程的模板,封装了复杂的线程开启等操作,封装了操作系统的差异性。
创建方式
- 1、自定义一个类继承Thread类,并重写run方法,该类的对象调用start方法运行。
public class SubThreadRun extends Thread {
@Override
public void run() {
for (int i = 0 ; i < 20 ; i++){
System.out.println("run方法中的"+i);
}
}
public static void main(String[] args) {
}
}
测试类
package com.lagou.thread;
public class SubThreadRunTest {
public static void main(String[] args) {
Thread t1 = new SubThreadRun();
//调用重写的run 本质上就是普通成员方法的调用 调用run方法后 再执行后面的代码
//t1.run();
//启动线程 jvm自动调用该线程类中的run方法
//相当于又启动一个线程 加上main方法的线程一共有两个线程
t1.start();
for (int i = 0 ; i < 20 ; i++){
System.out.println("main方法中的"+i);
}
}
}
- 2、实现Runnable接口并重写Run方法,创建该类的对象并作为参数来构造Thread类,Thread类的对象调用start方法
public class SubRunnableRun implements Runnable {
@Override
public void run() {
for (int i = 0 ; i < 20 ; i++){
System.out.println("run方法中的"+i);
}
}
}
测试类
package com.lagou.thread;
public class SubRunnableRunTest {
public static void main(String[] args) {
//创建自定义类型的对象 (实现Runnable类的对象)
Runnable srr = new SubRunnableRun();
//使用该对象作为参数创建Thread类型的对象
//由源码可知 经过构造方法的调用之后 Thread类中的成员变量target是srr
Thread t1 = new Thread(srr);
//使用Thread的对象调用start
//由于if (target != null) {target.run();} target此时是srr 而srr是Runnable类型 所以最终调用的是Runnable接口中的run()
t1.start();
for (int i = 0; i< 20 ;i++){
System.out.println("main" +i);
}
}
}
常用的方法
方法名称 | 功能 |
---|---|
Thread(String name) | 根据参数指定的名称来构造对象 |
Thread(Runnable target) | 根据参数指定的引用来构造对象,其中Runnable是个接口类型 |
Thread(Runnable target, String name) | 根据参数指定引用和名称来构造对象 |
void run() | 若使用Runnable引用构造了线程对象,调用该方法时最终调用接口中的版本;若没有使用Runnable引用构造线程对象,调用该方法时则啥也不做 |
void start() | 用于启动线程,Java虚拟机会自动调用该线程的run方法 |
执行流程
- 执行
main方法
的线程叫做主线程,执行run方法
的线程叫做新线程/子线程 main方法
是程序的入口,执行main方法
后,主线程在执行,当执行到start方法
后,子线程开始运行,一个线程变为两个,新启动的线程去执行run方法
的代码,主线程继续向下执行,互不影响- 当
run方法
代码执行完后,子线程结束;当main方法
代码执行完后,主线程结束。 - 两个线程执行没有明确的先后执行次序,由操作系统调度算法来决定。
继承Thread类和实现接口两种方法创建线程的比较
- 继承Thread类方法较于简单,但此类无法继承其他类,有局限性
- 实现Runnable接口代码较于复杂,但不影响该类继承其他类或实现其他接口,开发中推荐实现接口的方式创建线程
匿名内部类方式创建线程
package com.lagou.thread;
/**
* 匿名内部类创建线程
*/
public class ThreadNoNameTest {
public static void main(String[] args) {
//匿名内部类 方式一
Thread t1 = new Thread();*//*{
@Override
public void run() {
System.out.println("new Thread的重写");
}
};*//*
t1.start();
//优化后
new Thread(){
@Override
public void run() {
System.out.println(" newThread的重写");
}
}.start();
//方式二:接口作为参数 的匿名内部类
Runnable ra = new Runnable() {
@Override
public void run() {
System.out.println("重写接口的run");
}
};
Thread t2 = new Thread(ra);
t2.start();
//优化
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("重写接口中的run");
}
}).start();
//再优化 lamda 表达式
Runnable ra = ()-> System.out.println("lamda表达式重写的run");
new Thread(ra).start();
//再再优化
new Thread(()-> System.out.println("嵌入拉姆达表达式重写的run")).start();
}
}
线程的生命周期
- 新建状态 - 使用new关键字创建之后进入的状态,此时线程并没有开始执行。
- 就绪状态 - 调用start方法后进入的状态,此时线程还是没有开始执行。
- 运行状态 - 使用线程调度器调用该线程后进入的状态,此时线程开始执行,当线程的时间片执行完毕后任务没有完成时回到就绪状态。
- 消亡状态 - 当线程的任务执行完成后进入的状态,此时线程已经终止。
- 阻塞状态 - 当线程执行的过程中发生了阻塞事件进入的状态,如:sleep方法。
- 阻塞状态解除后进入就绪状态。
线程的id和名称
方法名称 | 功能 |
---|---|
long getId() | 获取调用对象所表示线程的编号 |
String getName() | 获取调用对象所表示线程的名称 |
void setName(String name) | 设置/修改线程的名称为参数指定的数值 |
static Thread currentThread() | 获取当前正在执行线程的引用 |
- 案例题目
自定义类继承Thread类并重写run方法,在run方法中先打印当前线程的编号和名称,然后将线程的名称修改为"zhangfei"后再次打印编号和名称。 要求在main方法中也要打印主线程的编号和名称。
/**
* 测试线程id和县城名称
*/
public class ThreadIdTest extends Thread{
@Override
public void run() {
System.out.println("子线程id是"+getId()+"子线程名称是"+getName());
setName("柳潇");
System.out.println("子线程id" + getId() + "子线程名称" + getName());
}
public static void main(String[] args) {
Thread t1 = new ThreadIdTest();
t1.start();
//获取当前正在执行线程的id和名称 也就是获取主线程的id和名称
System.out.println("主线程id"+Thread.currentThread().getId()+"主线程名称"+Thread.currentThread().getName());
}
}
常用的方法
方法名称 | 功能 |
---|---|
static void yield() | 使当前线程让出cpu,从运行状态进入Ruannable状态 |
static void sleep(times) | 使当前线程从运行状态进入Bolck状态,休眠times毫秒,再返回到Runnable状态,如果其他线程打断当前线程的Block(sleep), 就会发生InterruptedException。 |
int getPriority() | 获取线程的优先级,最高10 最低1 默认5 |
void setPriority(int newPriority) | 设置线程的优先级(优先级越高不代表一定先执行,但获取时间片的机会会更多) |
void join() | 等待该线程运行完成 |
void join(long millis) | 等待该线程运行millis秒 |
boolean isDaemon() | 判断是否为守护线程(随着主线程结束而结束) |
void setDaemon(boolean on) | 设置为守护线程 |
- 案例
编程创建两个线程,线程一负责打印1 ~ 100之间的所有奇数,其中线程二负责打印1 ~ 100之间的
所有偶数。在main方法启动上述两个线程同时执行,主线程等待两个线程终止
package com.lagou.thread;
/**
* 编程创建两个线程,线程一负责打印1 ~ 100之间的所有奇数,其中线程二负责打印1 ~ 100之间的
* 所有偶数。
* 在main方法启动上述两个线程同时执行,主线程等待两个线程终止。
*/
public class TwoThreadNumTest {
public static void main(String[] args) {
//使用实现接口方式创建线程1
Thread t1= new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1 ; i < 100 ; i+=2){
System.out.println("子线程1="+i);
}
}
});
//使用实现接口方式创建线程2
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 2; i < 100; i += 2) {
System.out.println("子线程2=" + i);
}
}
});
t1.start();
t2.start();
System.out.println("主线程开始等等");
try {
t1.join();//
t2.join();t1 t2结束后再执行主线程
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程等待结束");
}
}
线程同步机制
线程同步基本概念
- 当多个线程同时访问同一种共享资源时,可能会造成数据的覆盖等不一致性问题,此时就需要对线程之间进行通信和协调,该机制就叫做线程的同步机制
- 多线程并发读取同一个临界资源是会产生并发安全问题
- 异步操作:多线程并发的操作,各自独立运行。
- 同步操作:多线程串行的操作,先后执行的顺序。
Synchronized的解决方式
- 在Java语言中使用
synchronized
关键字来实现同步/对象锁机制从而保证线程执行的原子性,具体
方式如下: - 使用同步代码块的方式实现部分代码的锁定,格式如下:
synchronized(类类型的引用) { 编写所有需要锁定的代码; }
- 使用同步方法的方式实现所有代码的锁定。
直接使用synchronized关键字来修饰整个方法即可
该方式等价于: synchronized(this) { 整个方法体的代码 }
静态方法的锁定
- 当我们对一个静态方法加锁,如:
public synchronized static void xxx(){….}
- 那么该方法锁的对象是类对象。每个类都有唯一的一个类对象。获取类对象的方式:类名.class。
- 静态方法与非静态方法同时使用了
synchronized
后它们之间是非互斥关系的。 - 原因在于:静态方法锁的是类对象而非静态方法锁的是当前方法所属对象。
注意
使用synchronized
保证线程同步应当注意:
多个需要同步的线程在访问同步块时,看到的应该是同一个锁对象引用。
在使用同步块时应当尽量减少同步范围以提高并发的执行效率。
线程安全类和不安全类
StringBuffer
类是线程安全的类,但StringBuilder
类不是线程安全的类。
Vector
类和 Hashtable
类是线程安全的类,但ArrayList
类和HashMap
类不是线程安全的类。
Collections.synchronizedList()
和 Collections.synchronizedMap()
等方法可以使ArrayList
类和HashMap
安全。
死锁的概念
两个同步代码块嵌套,一个线程持有锁a,等待锁b ;另一个线程持有锁b,等待锁a;
- 线程一执行的代码:
public void run(){
synchronized(a){ //持有对象锁a,等待对象锁b
synchronized(b){
编写锁定的代码;
}
}
}
线程二执行的代码:
public void run(){
synchronized(b){ //持有对象锁b,等待对象锁a
synchronized(a){
编写锁定的代码;
}
}
}
注意 :以后的开发中尽量少使用同步代码块嵌套的结构
使用Lock使线程同步
基本概念
- 从
Java5
开始提供了更强大的线程同步机制—使用显式定义的同步锁对象来实现。 java.util.concurrent.locks.Lock
接口是控制多个线程对共享资源进行访问的工具。- 该接口的主要实现类是
ReentrantLock
(重入锁)类,该类拥有与synchronized
相同的并发性,在以后的线程安全控制中,经常使用ReentrantLock
类显式加锁和释放锁
Lock和Synchronized的比较
- Lock是显示锁,需要显示的加锁和释放锁;而
Synchronized
是隐式锁,执行完包裹的代码后自动释放 - Lock只能锁同步代码块,而
Synchronized
还可以锁同步方法 - 使用Lock锁性能好,因为Java虚拟机会花费较少的时间做线程调度
** Synchronized和Lock的使用**
package com.lagou.thread;
import java.util.concurrent.locks.ReentrantLock;
public class AccountRunnableTest implements Runnable {
private int balance; // 用于描述账户的余额
private Demo dm = new Demo();
private ReentrantLock lock = new ReentrantLock(); // 准备了一把锁 重入锁
public AccountRunnableTest() {
}
public AccountRunnableTest(int balance) {
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
@Override
public /*synchronized*/ void run() {
// 开始加锁
lock.lock();
// 由源码可知:最终是account对象来调用run方法,因此当前正在调用的对象就是account,也就是说this就是account
//synchronized (this) { // ok
System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
//synchronized (dm) { // ok
//synchronized (new Demo()) { // 锁不住 要求必须是同一个对象
// 1.模拟从后台查询账户余额的过程
int temp = getBalance(); // temp = 1000 temp = 1000
// 2.模拟取款200元的过程
if (temp >= 200) {
System.out.println("正在出钞,请稍后...");
temp -= 200; // temp = 800 temp = 800
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("请取走您的钞票!");
} else {
System.out.println("余额不足,请核对您的账户余额!");
}
// 3.模拟将最新的账户余额写入到后台
setBalance(temp); // balance = 800 balance = 800
//}
lock.unlock(); // 实现解锁
}
public static void main(String[] args) {
AccountRunnableTest account = new AccountRunnableTest(1000);
//AccountRunnableTest account2 = new AccountRunnableTest(1000);
Thread t1 = new Thread(account);
Thread t2 = new Thread(account);
//Thread t2 = new Thread(account2);
t1.start();
t2.start();
System.out.println("主线程开始等待...");
try {
t1.join();
//t2.start(); // 也就是等待线程一取款操作结束后再启动线程二
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("最终的账户余额为:" + account.getBalance()); // 600 800
}
}
class Demo{}
继承Thread类的方式
package com.lagou.thread;
public class AccountThreadTest extends Thread {
private int balance; // 用于描述账户的余额
private static Demo dm = new Demo(); // 隶属于类层级,所有对象共享同一个
public AccountThreadTest() {
}
public AccountThreadTest(int balance) {
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
@Override
public /*static*/ /*synchronized*/ void run() {
/*System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
//synchronized (dm) { // ok
//synchronized (new Demo()) { // 锁不住 要求必须是同一个对象
// 1.模拟从后台查询账户余额的过程
int temp = getBalance(); // temp = 1000 temp = 1000
// 2.模拟取款200元的过程
if (temp >= 200) {
System.out.println("正在出钞,请稍后...");
temp -= 200; // temp = 800 temp = 800
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("请取走您的钞票!");
} else {
System.out.println("余额不足,请核对您的账户余额!");
}
// 3.模拟将最新的账户余额写入到后台
setBalance(temp); // balance = 800 balance = 800
//}*/
test();
}
public /*synchronized*/ static void test() {
synchronized (AccountThreadTest.class) { // 该类型对应的Class对象,由于类型是固定的,因此Class对象也是唯一的,因此可以实现同步
System.out.println("线程" + Thread.currentThread().getName() + "已启动...");
//synchronized (dm) { // ok
//synchronized (new Demo()) { // 锁不住 要求必须是同一个对象
// 1.模拟从后台查询账户余额的过程
int temp = 1000; //getBalance(); // temp = 1000 temp = 1000
// 2.模拟取款200元的过程
if (temp >= 200) {
System.out.println("正在出钞,请稍后...");
temp -= 200; // temp = 800 temp = 800
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("请取走您的钞票!");
} else {
System.out.println("余额不足,请核对您的账户余额!");
}
// 3.模拟将最新的账户余额写入到后台
//setBalance(temp); // balance = 800 balance = 800
}
}
public static void main(String[] args) {
AccountThreadTest att1 = new AccountThreadTest(1000);
att1.start();
AccountThreadTest att2 = new AccountThreadTest(1000);
att2.start();
System.out.println("主线程开始等待...");
try {
att1.join();
//t2.start(); // 也就是等待线程一取款操作结束后再启动线程二
att2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("最终的账户余额为:" + att1.getBalance()); // 800
}
}
Object类的方法
方法名称 | 功能 |
---|---|
void wait() | 用于使得线程进入等待状态,直到其它线程调用notify()或notifyAll()方法 |
void wait(long timeout) | 用于进入等待状态,直到其它线程调用方法或参数指定的毫秒数已经过去为止 |
void notify() | 随机唤醒等待池里的一个线程 |
void notifyAll() | 唤醒等待池里的所有进程 |
package com.lagou.thread;
/**
* 线程通信的测试
*/
public class ThreadCommunicateTest implements Runnable{
private int cnt = 1;
@Override
public void run() {
while (true){
synchronized (this) {
//每当有一个线程进来后叫醒其他线程 代码被锁住并不会出现抢占资源
notify(); //必须在锁定的同步代码里进行通信
if (cnt<=100){
System.out.println("线程"+Thread.currentThread().getName()+"中:cnt"+cnt);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
cnt++;
try {
wait();//打印完一次 进入等待状态 自动释放对象锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
else {
break;
}
}
}
}
public static void main(String[] args) {
ThreadCommunicateTest tct = new ThreadCommunicateTest();
Thread t1 = new Thread(tct);
t1.start();
Thread t2 = new Thread(tct);
t2.start();
}
}
Callable接口
- Java5开始新增加创建线程的第三种方式为实现
java.util.concurrent.Callable
接口 call()
方法用于计算结果并返回
FuthreTask类
java.util.concurrent.FutureTask
类用于描述可取消的异步计算,该类提供了Future接口
的基本实现,包括启动和取消计算、查询计算是否完成以及检索计算结果的方法,也可以用于获取方法调用后的返回结果。
方法声明 | 功能 |
---|---|
FutureTask(Callable callable) | 根据Callable接口的引用来创建一个未来任务 |
V get() | 获取call方法计算的结果 |
public class ThreadCallableTest implements Callable {
@Override
public Object call() throws Exception {
// 计算1 ~ 10000之间的累加和并打印返回
int sum = 0;
for (int i = 1; i <= 10000; i++) {
sum +=i;
}
System.out.println("计算的累加和是:" + sum); // 50005000
return sum;
}
public static void main(String[] args) {
ThreadCallableTest tct = new ThreadCallableTest();//Callable接口的引用
FutureTask ft = new FutureTask(tct);//将引用传入构造FutureTask的对象
Thread t1 = new Thread(ft);//将任务对象传入构造线程
t1.start();
Object obj = null;
try {
obj = ft.get();//获取call方法的计算结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("线程处理方法的返回值是:" + obj); // 50005000
}
}
线程池
线程池的由来
- 再服务器编程模型中,每一个客户端连接用一个单独的线程为之服务,会话结束后,线程随之关闭,反复的创建销毁线程会影响服务器性能,所以产生了线程池
线程池的概念
- 线程池的概念:首先创建一些线程,它们的集合称为线程池,当服务器接受到一个客户请求后,就从线程池中取出一个空闲的线程为之服务,服务完后不关闭该线程,而是将该线程还回到线程池中。
- 在线程池的编程模式下,任务是提交给整个线程池,而不是直接交给某个线程,线程池在拿到任务后,它就在内部找有无空闲的线程,再把任务交给内部某个空闲的线程,任务是提交给整个线程池,一个线程同时只能执行一个任务,但可以同时向一个线程池提交多个任务。
相关方法
-
从Java5开始提供了线程池的相关类和接口:
java.util.concurrent.Executors
类和java.util.concurrent.ExecutorService
接口。 -
其中
Executors
是个工具类和线程池的工厂类,可以创建并返回不同类型的线程池,常用方法如下:
方法声明 | 功能 |
---|---|
static ExecutorService newCachedThreadPool() | 创建一个可根据需要创建新线程的线程池 |
static ExecutorService newFixedThreadPool(int nThreads) | 创建一个可重用的固定线程数的线程池 |
static ExecutorService newSingleThreadExecutor() | 创建只有单个线程的线程池 |
- 其中
ExecutorService接口
是真正的线程池接口,主要实现类是ThreadPoolExecutor
,常用方法
如下:
方法声明 | 功能 |
---|---|
void execute(Runnable command) | 执行任务和命令,Runnable版本 |
Future submit(Callable task) | 执行任务和命令 Callable版本 |
void shutdown() | 启动有序关闭 |
/*
* 演示线程池的创建
* Executor:线程池接口 只有一个execte()方法
* ExecutorService:包含管理线程的一些方法 submit、shutdown
* ThreadPoolExecutor
* ScheduledThreadPoolExecutor
* Executorx:创建线程的工具类
* (1)创建固定线程个数的线程池
* (2)创建缓存线程池,由任务的多少决定
* (3)创建单线程池
* (4)创建调度线程池 调度:周期 定时执行
*/
public class CreateXcc {
public static void main(String[] args) {
//1.1创建固定个数的线程池
//ExecutorService eService =Executors.newFixedThreadPool(4);
//1.2创建缓存线程池 线程个数由提交任务决定
ExecutorService eService=Executors.newCachedThreadPool();
//1.3创建单线程池
//ExecutorService eService = Executors.newSingleThreadExecutor();
//1.4创建调度线程池 参数:线程个数
//ExecutorService eService = Executors.newScheduledThreadPool(corePooleSize)
//提交任务
Runnable runnable = new Runnable() {
private int ticket=100;
private Object object = new Object();
@Override
public void run() {
while(true) {
synchronized (object) {//同步锁 防止卖出同一张票
if(ticket<=0) {
break;
}
System.out.println(Thread.currentThread().getName()+"卖出了"+ticket+"张票");
ticket--;
}
}
}
};
for (int i = 0; i < 4; i++) {
eService.execute(runnable);
}
//关闭线程池
eService.shutdown();
}
}
Callable 和线程池
public class CallableDemo2 {
public static void main(String[] args) throws InterruptedException, ExecutionException {
//1 创建线程池
ExecutorService eService = Executors.newFixedThreadPool(1);
//2 提交任务
Future<Integer> future= eService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName()+"开始");
int s=0;
for(int i = 0;i<10;i++) {
s++;
}
return s;
}
});
// 3 获取结果
Integer sumInteger = future.get();
System.out.println(sumInteger);
// 4 关闭线程池
eService.shutdown();
}
}