多线程
Process与Thread
- 说起进程，就得说一下程序，程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。
- 而进程则是执行程序的一次执行过程，它是动态的概念。是系统资源分配的单位
- 通常在一个进程中可以有若干个线程，当然一个进程中至少一个线程（main线程），不然没有存在的意义。线程是CPU调度和执行的单位。
- 注意：很多多线程都是模拟出来的，真正的多线程是指有多个CPU，即多核。如服务器。如果是模拟出来的多线程，在同一时间点，CPU只能执行一个代码，因为切换的很快，所以就有了同时执行的错觉。
核心思想：
- 线程是独立的执行路径
- 在程序运行时，即时没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
- main()称之为主线程，为系统的入口，用于执行整个程序；
- 在一个进程中，如果开辟了多个线程，线程的运行由调度器（CPU）安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的。
- 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；
- 线程会带来额外的开销，如CPU调度时间，并发控制开销
- 每一个线程在自己的工作内存交互，内存控制不当会造成数据不一致
创建线程的方式
3种创建方式：
- Thread class -->继承Thread类
- Runnable 接口 -->实现Runnable 接口
- Callable接口 -->实现Callable接口
继承Thread类
过程步骤：
- 自定义线程类继承Thread 类
- 重写run()方法，编写线程执行体
- 创建线程对象，调用start()方法启动线程。
- 注意：线程开启不一定立即执行，由CPU调度执行
实现Runnable 接口
过程步骤：
- 自定义类实现Runnable 接口
- 实现run()方法，编写线程执行体
- 创建线程对象，调用start()方法启动线程
public class MyRunnable implements Runnable{ //实现Runnable接口
@Override
public void run() { //重新run()方法
for (int i = 0; i <20 ; i++) {
System.out.println("run方法执行"+i);
}
}
public static void main(String[] args) {
//创建实现Runnable接口的实现类对象
MyRunnable myRunnable = new MyRunnable();
//创建线程对象，通过线程对象来开启线程（代理）
new Thread(myRunnable).start();
for (int i = 0; i <20 ; i++) {
System.out.println("主线程执行"+i);
}
}
}
两种方法对比
-
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免单继承的局限性
-
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象+Thread对象.start()
- 推荐使用：避免单继承的局限性，灵活方便，方便同一个对象被对个线程使用
实现Callable接口
过程步骤：
- 实现Callable接口，需要返回值类型
- 重写call方法，需要抛出异常
- 创建目标对象
- 创建执行服务器：ExecutorServer ser=Executors.newFixedThreadPool(n);
- 提交执行：Future result=ser.submit(t1);
- 获取结果：boolean r1=result.get();
- 关闭服务：ser.shutdownNow();
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5twsZOYV-1620812936176)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210506111806279.png)]
静态代理模式
- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色：new 代理对象（真实对象）
- 所以创建代理类的时候要有一个目标参数指向真实对象
好处：
- 代理对象可以做很多真实对象做不了的事情
- 真实对象专注做自己的事情
Lambda表达式
为什么要使用lambda表达式？
- 避免匿名内部类定义过多
- 可以让代码看起来很简洁
- 去掉一堆没用意义的代码，只留下核心的逻辑
- 理解Functional Interface （函数式接口）是学习lambda表达式的关键所在
- 函数式接口的定义：
- 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。
- 对于函数式接口，我们可以通过lambda表达式来创建该接口的对象
(params) ->expression[表达式]
(params) ->statement[语句]
(params) ->{statements}
总结：
- lambda表达式只能有一行代码的情况下才能去掉括号，多行用代码块包裹
- 前提是接口为函数式接口
- 多个参数也可以去掉参数类型，要去掉就都要去掉，必须加上括号
- 写参数的括号也可以去掉（只有一个参数的时候）
线程状态
- 创建状态new：Thread thread =new Thread();线程对象一旦创建就进入到了新生状态。
- 就绪状态：当调用start()方法，线程立即进入就绪状态，但不意味着立即执行调度。
- 运行状态：进入运行状态，线程才真正执行线程体的代码块（CPU调度就绪状态的线程）
- 阻塞状态：当调用sleep，wait或同步锁定时，线程进入阻塞状态，就是代码不在往下执行，阻塞事件解除后，重新进入就绪状态，等待CPU调度执行
- 死亡状态dead：线程中断或者结束，一旦进入死亡状态，就不能再次启动。
停止线程
- 不推荐使用JDK提供的stop()、destroy()方法（已废弃）
- 推荐线程自己停止下来
- 建议使用一个标志位进行终止变量，当flag=false，则终止线程运行
public class StopThread implements Runnable{
//定义标志位来实现停止线程
private boolean flag=true;
@Override
public void run() {
int i=0;
while(flag){
System.out.println("线程正在运行"+ i++);
}
}
public void stop(){ //定义stop方法停止线程
this.flag=false;
}
public static void main(String[] args) {
StopThread s1=new StopThread();
new Thread(new StopThread()).start();
for (int i = 0; i <1000 ; i++) {
System.out.println("main正在运行"+i);
if(i==900){
s1.stop();
}
}
}
}
线程休眠
sleep可以放大问题的发生性
- sleep（时间）指定当前线程阻塞的毫秒数
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时，倒计时等
- 每一个对象都有一个锁，sleep不会释放锁
//用延时来模拟持续显示系统时间
public class newState {
public static void main(String[] args) throws InterruptedException {
Date date = new Date(System.currentTimeMillis()); //打印系统当前时间
while (true){
Thread.sleep(1000);
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));//以当前格式打印时间
date=new Date(System.currentTimeMillis()); //更新当前时间
}
}
}
线程礼让 yield
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程运行状态转为就绪状态
- 让CPU重新调度，礼让不一定成功，看CPU随机
线程强制执行 join
- join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
- 插队thread.join();
线程优先级
-
线程的优先级用数字表示，范围1~10
- Thread.MIN_PRIORITY=1;
- Thread.MAX_PRIORITY=10;
- Thread.NORM_PRIORITY=5;
-
使用以下方式改变或获取优先级
- getPriority()
- setPriority(int num)
-
注意优先级的设定建议在start()调度之前
-
优先级低只是意味着获取调度的概率低，并不是优先级低就不会调用，这都是看CPU随机调度
守护线程（daemon）
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如，后台记录操作日志，监控内存，垃圾回收等待
thread.setDaemon（true）；默认情况下是false（为用户线程），true为守护线程
线程同步
- 由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的锁，独自占有资源，其他线程必须等待使用后释放锁即可，存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
线程不安全的三大案例：
1、买票
//不安全的买票
public class Unsafe01 {
static class buyticket implements Runnable{
private int ticketnum=10; //定义票数
boolean flag=true; //外部停止循环
@Override
public void run() {
//买票
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
//判断是否有票
if(ticketnum<=0){
flag=false;
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketnum--);
}
}
public static void main(String[] args) {
buyticket station = new buyticket();
new Thread(station,"老师").start();
new Thread(station,"你").start();
new Thread(station,"我").start();
}
}
2、银行取钱
//模拟银行取钱
public class Unsafe02 {
public static void main(String[] args) {
Account account=new Account(1000,"旅游基金");
Drawing me = new Drawing(account, 200, "我");
Drawing girlFriend = new Drawing(account, 900, "girlFriend");
me.start();
girlFriend.start();
}
//账户
static class Account{
int money; //余额
String name; //卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行：模拟取钱
static class Drawing extends Thread{
Account account; //账户
int drawmoney; //取了多少
int nowmoney; //手里的钱
public Drawing(Account account,int drawmoney,String name){
super(name);
this.account=account;
this.drawmoney=drawmoney;
}
//取钱
@Override
public void run() {
//判断是否有钱
if(account.money-drawmoney<0){
System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
return;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额
account.money=account.money-drawmoney;
//手里的钱
nowmoney=nowmoney+drawmoney;
System.out.println(account.name+"余额为："+account.money);
//this.getName()等价于Thread.currentThread().getName()，因为Drawing继承了Thread
System.out.println(this.getName()+"手里的钱"+nowmoney);
}
}
}
3、线程不安全的集合（除了set）
//线程不安全的集合
public class Unsafe03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i <10000 ; i++) { //两个线程同一时间操作了同一个位置
new Thread(()->{
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
同步方法及同步块synchronized
同步方法：
- 由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法synchronized方法和synchronized同步块。
同步方法：public synchronized void method(int args){}
-
synchronized方法控制对“对象”的访问，每一个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大方法声明为synchronized将会影响效率
package Unsafe;
//不安全的买票
public class safe01 {
static class buyticket implements Runnable{
private int ticketnum=10; //定义票数
boolean flag=true; //外部停止循环
@Override
public void run() {
//买票
while (flag){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private synchronized void buy() throws InterruptedException {
//判断是否有票
if(ticketnum<=0){
flag=false;
return;
}
//模拟延时
Thread.sleep(100);
//买票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketnum--);
}
}
public static void main(String[] args) {
buyticket station = new buyticket();
new Thread(station,"老师").start();
new Thread(station,"你").start();
new Thread(station,"我").start();
}
}
同步块：
-
同步块：synchronized（Obj）{}
-
Obj称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器（即要进行增删改的资源）
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
-
同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其中代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
package Unsafe;
//模拟银行取钱
public class safe02 {
public static void main(String[] args) {
Account account=new Account(1000,"旅游基金");
Drawing me = new Drawing(account, 200, "我");
Drawing girlFriend = new Drawing(account, 900, "girlFriend");
girlFriend.start();
me.start();
}
//账户
static class Account{
int money; //余额
String name; //卡名
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行：模拟取钱
static class Drawing extends Thread{
Account account; //账户
int drawmoney; //取了多少
int nowmoney; //手里的钱
public Drawing(Account account,int drawmoney,String name){
super(name);
this.account=account;
this.drawmoney=drawmoney;
}
//取钱
@Override
public void run() {
synchronized (account){
//判断是否有钱
if(account.money-drawmoney<0){
System.out.println(Thread.currentThread().getName()+"钱不够，取不了");
return;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内余额
account.money=account.money-drawmoney;
//手里的钱
nowmoney=nowmoney+drawmoney;
System.out.println(account.name+"余额为："+account.money);
//this.getName()等价于Thread.currentThread().getName()，因为Drawing继承了Thread
System.out.println(this.getName()+"手里的钱"+nowmoney);
}
}
}
}
package Unsafe;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class safe03 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
for (int i = 0; i <10000 ; i++) { //两个线程同一时间操作了同一个位置
new Thread(()->{
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
}
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
JUC安全类型的集合：CopyOnWriteArrayList
JUC包指的是java.util.concurrent（并发）
死锁
产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用
- 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
（需要的资源只有一份，可以用static来修饰）
Lock
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问资源之前应先获得Lock对象
- ReentrantLock类实现了Lock，它拥有synchronized相同的并发性和内存语义，在现实线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁
格式如下：
class A{
private final ReentrantLock lock=new ReentrantLock(); //定义锁
public void m{
lock.lock(); //加锁
try{
//保证线程安全的代码
}finally{
lock.unlock(); //释放锁
}
}
}
synchronized 与Lock的对比：
- Lock是显示锁（手动开启和关闭锁，别忘了关闭锁），synchronized是隐式锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码块锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）
- 优先使用顺序：
- Lock>同步代码块（已经进入了方法体，分配了相应的资源）>同步方法（在方法体之外）
package Unsafe;
import java.util.concurrent.locks.ReentrantLock;
public class Testlock {
public static void main(String[] args) {
buyticket b1=new buyticket();
new Thread(b1).start();
new Thread(b1).start();
new Thread(b1).start();
}
static class buyticket implements Runnable{
int ticketnum=10;
private final ReentrantLock lock=new ReentrantLock();
@Override
public void run() {
lock.lock();
try{
while (true){
if(ticketnum>0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketnum--);
}else{
break;
}
}
}finally {
lock.unlock();
}
}
}
}
生产者与消费者问题(线程之间的通信)
管程法:
- 生产者：负责生产数据的模块（可能是方法，对象，线程，进程）
- 消费者：负责处理数据的模块（可能是方法，对象，线程，进程）
- 缓冲区：消费者不能直接使用生产者的数据，他们之间有个“缓冲区”，生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
package Unsafe;
public class Test1 {
public static void main(String[] args) {
Syncontainer container = new Syncontainer();
new Productor(container).start();
new Consumer(container).start();
}
//生产者
static class Productor extends Thread{
Syncontainer syncontainer;
public Productor(Syncontainer syncontainer){
this.syncontainer=syncontainer;
}
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
syncontainer.push(new Chicken(i));
System.out.println("生产了"+i+"只鸡");
}
}
}
//消费者
static class Consumer extends Thread{
Syncontainer syncontainer;
public Consumer(Syncontainer syncontainer){
this.syncontainer=syncontainer;
}
@Override
public void run() {
for (int i = 0; i <100 ; i++) {
System.out.println("消费了-->"+syncontainer.pop().id+"只鸡");
}
}
}
//产品
static class Chicken{
int id;
public Chicken(int id) {
this.id = id;
}
}
//缓冲区
static class Syncontainer {
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
int count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken) {
//判断容器是否满了
if (count == chickens.length) {
//等待消费者消费，生产者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果没满就往里面加
chickens[count] = chicken;
count++;
//可以通知消费者了
this.notifyAll();
}
//消费者消费
public synchronized Chicken pop() {
//判断能否消费
if (count == 0) {
//等待生产者生产，消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//可以消费了
count--;
Chicken chicken = chickens[count];
//吃完了，通知生产者生产
this.notifyAll();
return chicken;
}
}
}
信号灯法：
package Unsafe;
//信号灯法（生产者和消费者问题）
public class Test02 {
public static void main(String[] args) {
Tv tv = new Tv();
new Player(tv).start();
new Watcher(tv).start();
}
//生产者（演员）
static class Player extends Thread{
Tv tv;
public Player(Tv tv){
this.tv=tv;
}
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
if(i%3==0){
this.tv.play("正在播放广告");
}else{
this.tv.play("名侦探柯南正在播放");
}
}
}
}
//消费者（观众）
static class Watcher extends Thread{
Tv tv;
public Watcher(Tv tv){
this.tv=tv;
}
@Override
public void run() {
for (int i = 0; i <20 ; i++) {
tv.watch();
}
}
}
//产品（节目）
static class Tv{
//演员表演，观众等待 true
//演员等待，观众观看 false
String voice; //表演的节目
boolean flag=true; //标志位
//表演
public synchronized void play(String voice){
if(!flag){ //演员等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(voice);
//通知观众观看
this.notifyAll();
//更新数据
this.voice=voice;
this.flag=!this.flag;
}
//观看
public synchronized void watch(){
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("观众观看了"+voice);
//通知演员表演
this.notifyAll();
this.flag=!this.flag;
} }
}
线程池
-
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
-
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。
-
好处：
- 提高响应速度（减少了创建线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次创建）
- 便于线程管理
-
线程池相关类：ExecutorService 和Executors
-
ExecutorService：真正的线程池接口。常见子类有ThreadPoolExecutor
- void execute(Runnable command) :执行任务/命令，没有返回值，一般用来执行Runnable
- Futuresubmit(Callable task)：执行任务，有返回值，一般用来执行Callable
- void shutdowm()：关闭线程池
-
Executor：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
package Unsafe;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestPool {
public static void main(String[] args) {
//创建服务，创建线程池
ExecutorService service= Executors.newFixedThreadPool(10); //线程池大小
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
static class MyThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
}
41万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
