进程,线程,多线程
1. Process和Thread
- 程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念
- 而进程则是执行程序的一次执行过程,它是一个动态的概念,是系统资源分配的单位
- 通常在一个进程中可以包含若干个线程,当然一个进程中至少有一个线程,不然没有存在的意义,线程是cpu调度和执行的单位
- 注意:很多多线程是模拟出来的,真正的多线程指有多个CPU,即多核,如服务器。如果模拟出来的多线程,即在一个cpu的情况下,在同一个时间点,cpu只能执行一个代码,因为切换的很快,所以就有同时执行的错觉
2. 核心概念
- 线程就是独立的执行路径
- 在程序运行时,即使没有自己创建教程,后台也会有多个线程,如主线程,gc线程
- main() 称之为主线程,为系统的入口,用于执行整个程序
- 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能人为干预的
- 对同一份资源操作时,会存在资源抢夺的问题,需要加入并发控制
- 线程会带来额外的开销,如cpu调度时间,并发控制开销
- 每个线程在自己的工作内存交互,内存控制不当会造成数据不一致
一、线程创建
三种创建方式
Thread class :继承Thread类(重点)
Runnable 接口 :实现Runnable接口(重点)
Callable 接口 :实现Callable接口(了解)
1. 继承Thread类
- 自定义线程类Thread类
- 重写run()方法,编写线程执行体
- 创建线程对象,调用start()方法启动线程
- 线程不一定立即执行,CPU安排调度
package com.tyrant.lesson01;
//创建线程方式一:继承Thread类,重写run()方法,调用start开启线程
public class ThreadDemo01 extends Thread {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("run线程" + i);
}
}
public static void main(String[] args) {
//main线程,主线程
//调用start()方法开启线程
new ThreadDemo01().start();
for (int i = 0; i < 20; i++) {
System.out.println("main线程" + i);
}
}
}
练习多线程下载网络上的图片
package com.tyrant.lesson01;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//练习Thread,实现多线程同步下载图片
public class ThreadDemo02 extends Thread {
private String url;
private String file;
public ThreadDemo02(String url,String file){
this.url = url;
this.file = file;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getFile() {
return file;
}
public void setFile(String file) {
this.file = file;
}
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,file);
System.out.println("下载的文件名为:" + file);
}
public static void main(String[] args) {
ThreadDemo02 t1 = new ThreadDemo02("https://i0.hdslb.com/bfs/new_dyn/4c910c430d041f3b6b7c41609c79ab232073012767.jpg","图1.jpg");
ThreadDemo02 t2 = new ThreadDemo02("https://i0.hdslb.com/bfs/new_dyn/d6e5c9b2b51b89679a097fa2ae5cc749623441612.png","图2.png");
ThreadDemo02 t3 = new ThreadDemo02("https://i0.hdslb.com/bfs/new_dyn/3855c892ddd453c06c71a621ddf4254c434565011.jpg","图3.jpg");
// System.out.println(t1.getFile());
// System.out.println(t2.getFile());
// System.out.println(t3.getFile());
/*
try {
//要创建不存在的文件
new File(t1.getFile()).createNewFile();
new File(t2.getFile()).createNewFile();
new File(t3.getFile()).createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
*/
t1.start();
t2.start();
t3.start();
}
}
//下载器
class WebDownloader {
//下载方法
public void downloader(String url,String file){
try {
File f = new File(file);
if (!f.isFile()) {
f.createNewFile();
}
FileUtils.copyURLToFile(new URL(url),f);
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常:downloader方法出现问题");
}
}
}
2. 实现Runnable接口
- 定义MyRunnable类实现Runnable接口
- 实现run()方法,编写线程执行体
- 创建线程对象,调用start()方法启用线程
- 推荐使用Runnable对象,因为Java单继承的局限性
package com.tyrant.lesson01;
//创建线程方式2:实现Runnable接口,重写run方法,执行线程需要丢入Runnable接口实现类,调用start方法
public class ThreadDemo03 implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 200; i++) {
System.out.println("run线程");
}
}
public static void main(String[] args) {
//创建Runnable接口的实现类对象,创建线程对象,通过线程对象来开启我们的线程代理
new Thread(new ThreadDemo03()).start();
for (int i = 0; i < 200; i++) {
System.out.println("main线程");
}
}
}
3. 小结
-
继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程:子类对象start()
- 不建议使用:避免OOP单继承局限性
-
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程:传入目标对象+Thread对象.start()
- 推荐使用:避免单继承局限性,灵活方便,方便同一对象被多个线程使用
4. 并发问题
package com.tyrant.lesson01;
//多个线程同时操作同一个对象
//买火车票的例子
public class ThreadDemo04 implements Runnable {
//票是
private int ticketNums = 10;
@Override
public void run() {
while (true){
if (ticketNums <= 0){
System.out.println("火车票已售空!");
break;
}
//买票
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +
"买到了倒数第" + ticketNums +
"张票");
ticketNums--;
}
}
public static void main(String[] args) {
ThreadDemo04 ticket = new ThreadDemo04();
new Thread(ticket,"张三").start();
new Thread(ticket,"李四").start();
new Thread(ticket,"王五").start();
/*
王五买到了倒数第10张票
李四买到了倒数第10张票
张三买到了倒数第10张票
张三买到了倒数第7张票
李四买到了倒数第7张票
王五买到了倒数第7张票
李四买到了倒数第4张票
张三买到了倒数第4张票
王五买到了倒数第4张票
张三买到了倒数第1张票
火车票已售空!
王五买到了倒数第1张票
火车票已售空!
李四买到了倒数第1张票
火车票已售空!
Process finished with exit code 0
*/
}
}
发现问题:在多个线程操作同一资源的时候会发生紊乱,线程不安全,如何解决呢?
5. 案例:龟兔赛跑
- 首先需要赛道距离,然后要离终点越来越近
- 判断比赛是否结束
- 打印出胜利者
- 龟兔赛跑开始
- 兔子需要睡觉,乌龟赢得比赛
package com.tyrant.lesson01;
public class Race implements Runnable {
//胜利者
private String winner;
@Override
public void run() {
for (int i = 0; i <= 1000; i++) {
//当一方到达终点时比赛结束
if (gameOver(i)) {
break;
}
if (Thread.currentThread().getName().equals("兔子")){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + "-->跑了"+ (i+1) +"步");
}
}
//比赛结束方法
private boolean gameOver(int steps){
if (winner != null){
return true;//有胜利者,已经结束了
}
if (steps >= 1000){
winner = Thread.currentThread().getName();
System.out.println("胜利者是:" + winner);
return true;
}
return false;//没结束
}
public static void main(String[] args) {
Race race = new Race();
new Thread(race,"兔子").start();
new Thread(race,"乌龟").start();
}
}
6. 实现Callable接口
-
实现Callable接口,需要返回值类型
-
重写call方法,需要抛出异常
-
创建目标对象
-
创建执行服务:ExecutorServer ser = Executors.newFixedThreadPool(1);
-
执行提交:Future
result1 = ser.submit(t1); -
获取结果:boolean r1 = result1.get();
-
关闭服务:ser.shutdownNow();
-
总结:
-
能定义返回值
-
可以抛出异常
-
package com.tyrant.lesson02;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
public class CallableDemo01 implements Callable {
private String url;
private String file;
public CallableDemo01(String url,String file){
this.url = url;
this.file = file;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getFile() {
return file;
}
public void setFile(String file) {
this.file = file;
}
public static void main(String[] args) {
CallableDemo01 t1 = new CallableDemo01("https://i0.hdslb.com/bfs/new_dyn/4c910c430d041f3b6b7c41609c79ab232073012767.jpg","图1.jpg");
CallableDemo01 t2 = new CallableDemo01("https://i0.hdslb.com/bfs/new_dyn/d6e5c9b2b51b89679a097fa2ae5cc749623441612.png","图2.png");
CallableDemo01 t3 = new CallableDemo01("https://i0.hdslb.com/bfs/new_dyn/3855c892ddd453c06c71a621ddf4254c434565011.jpg","图3.jpg");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future<Boolean> r1 = ser.submit(t1);
Future<Boolean> r2 = ser.submit(t2);
Future<Boolean> r3 = ser.submit(t3);
//获取结果
try {
Boolean b1 = r1.get();
Boolean b2 = r2.get();
Boolean b3 = r3.get();
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
} catch (Exception e) {
e.printStackTrace();
}
//关闭服务
ser.shutdown();
}
@Override
public Boolean call() throws Exception {
WebDownloader01 webDownloader01 = new WebDownloader01();
webDownloader01.downloader(url,file);
System.out.println("下载的文件名为:" + file);
return true;
}
}
//下载器
class WebDownloader01 {
//下载方法
public void downloader(String url,String file){
try {
File f = new File(file);
if (!f.isFile()) {
f.createNewFile();
}
FileUtils.copyURLToFile(new URL(url),f);
} catch (IOException e) {
e.printStackTrace();
System.out.println("IO异常:downloader方法出现问题");
}
}
}
7. 静态代理
- 真实对象和代理对象都要实现同一个接口
- 代理对象要代理真实角色
package com.tyrant.lesson02;
public class StaticProxyDemo01 {
public static void main(String[] args) {
WeddingCompany weddingCompany = new WeddingCompany(new You());
weddingCompany.happyMarry();
}
}
interface Marry{
//接口内方法没有方法体
void happyMarry();
}
//真实角色,你去结婚
class You implements Marry{
@Override
public void happyMarry() {
System.out.println("你结婚了");
}
}
//代理角色,帮助你结婚
class WeddingCompany implements Marry{
private Marry target;
public WeddingCompany(Marry target) {
this.target = target;
}
@Override
public void happyMarry() {
before();
this.target.happyMarry();//真实角色结婚
after();
}
private void before() {
System.out.println("结婚前,布置现场");
}
private void after() {
System.out.println("结婚后,收尾款");
}
}
好处:
- 代理对象可以做很多真实对象做不了的事情
- 真实对象专注做自己的事情
8. Lambda表达式
- 为什么要使用lambda表达式
- 避免匿名内部类定义过多
- 可以让你的代码看起来很简洁
- 去掉了一堆没有意义的代码,只留下核心的逻辑
(params) -> expression //表达式
(params) -> statement //语句
(params) -> {statements} //语句块
- 理解Functional Interface(函数式接口)是学习Java8 lambda表达式的关键所在
- 函数式接口的定义:
- 任何接口,如果只包含唯一一个抽象方法,那么他就是一个函数式接口
- 对于函数式接口,我们可以通过lambda表达式来创建该接口的对象
无参构造:
package com.tyrant.lesson02;
//推导lambda表达式
public class LambdaDemo01 {
//3. 静态内部类
static class Everyone02 implements Goo{
@Override
public void Let() {
System.out.println("这是一个Lambda表达式的测试,来自Everyone02");
}
}
public static void main(String[] args) {
new Everyone01().Let();
new Everyone02().Let();
//4. 局部内部类
class Everyone03 implements Goo{
@Override
public void Let() {
System.out.println("这是一个Lambda表达式的测试,来自Everyone03");
}
}
new Everyone03().Let();
//5. 匿名内部类,没有类的名称,必须借助接口或者父类
new Goo() {
@Override
public void Let() {
System.out.println("这是一个Lambda表达式的测试,来自匿名内部类");
}
}.Let();
//6. Lambda表达式
Goo goo = ()-> {System.out.println("这是一个Lambda表达式的测试,来自Lambda表达式");};
goo.Let();
}
}
//1. 定义一个函数式接口
interface Goo{
void Let();
}
//2. 实现类
class Everyone01 implements Goo{
@Override
public void Let() {
System.out.println("这是一个Lambda表达式的测试,来自Everyone01");
}
}
有参构造:
package com.tyrant.lesson02;
public class LambdaDemo02 {
//静态内部类
static class player02 implements Badminton{
@Override
public void price(int ball, int pai, int chang) {
int all = 0;
all = ball + pai + chang;
System.out.println("2号打羽毛球的费用是:" + all);
}
}
public static void main(String[] args) {
//局部内部类
class player03 implements Badminton{
@Override
public void price(int ball, int pai, int chang) {
int all = 0;
all = ball + pai + chang;
System.out.println("3号打羽毛球的费用是:" + all);
}
}
//匿名内部类
Badminton badminton = new Badminton() {
@Override
public void price(int ball, int pai, int chang) {
int all = 0;
all = ball + pai + chang;
System.out.println("4号打羽毛球的费用是:" + all);
}
};
//lambda表达式
/* Badminton badminton1 = (ball, pai, chang) -> {
int all = 0;
all = ball + pai + chang;
System.out.println("5号打羽毛球的费用是:" + all);
};*/
//简化1. 去掉表达式类型
Badminton badminton1 = (ball, pai, chang) -> {
int all = 0;
all = ball + pai + chang;
System.out.println("5号打羽毛球的费用是:" + all);
};
//简化2. 去掉括号(单个参数)
//简化3. 去掉花括号(只有单行代码)
new player01().price(60,200,40);
new player02().price(80,400,40);
new player03().price(30,20,40);
badminton.price(400,1500,40);
badminton1.price(150,1000,40);
}
}
//定义一个接口
interface Badminton {
void price(int ball,int pai,int chang);
}
//1. 外部类
class player01 implements Badminton{
@Override
public void price(int ball, int pai, int chang) {
int all = 0;
all = ball + pai + chang;
System.out.println("1号打羽毛球的费用是:" + all);
}
}
总结:
- 使用lambda表达式的前提是接口为函数式接口
- lambda表达式只有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块包裹住
- 多个参数也可以去掉参数类型,要去掉就全去掉,必须加上括号
二、线程状态
线程的五大状态:创建状态,就绪状态,运行状态,阻塞状态,结束状态
new :Thread t = new Thread(); 线程对象创建时就是创建态
就绪态:调用start()方法,线程进入就绪态,但不意味着立即调度执行
运行态:进入运行状态,线程才真正执行线程体的代码块
阻塞态:当调用sleep,wait或同步锁定时,线程进入阻塞状态,此时代码不往下执行,阻塞事件解除后,重新进入就绪态,等待cpu调度执行
dead:线程中断或者结束,一旦进入死亡状态,就不能再次启动
方法:
setPriority(int newPriority)
:更改线程的优先级
static void sleep(long millis)
:在指定的毫秒数内让当前正在执行的线程休眠
void join()
:合并线程,等待该线程终止其他线程才能执行
static void yield()
:暂停当前正在执行的线程对象,并执行其他线程
void interrupt()
:中断线程,不推荐这个方法
boolean isAlive()
:测试线程是否处于活动状态
1. 停止线程
- 不推荐使用JDK提供的stop()、destroy()方法
- 推荐让线程自己停下来
- 建议使用一个标志位作为终止变量,当flag = false,则终止线程运行
package com.tyrant.lesson03;
//测试stop
//1. 建议线程正常停止 --> 利用次数,不建议死循环
//2. 建议使用标志位 --> 设置一个标志位
//3. 不要使用stop或者destroy等过时或者JDK不建议使用的方法
public class StopDemo01 implements Runnable {
//1. 设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag){
System.out.println("run线程正在运行···" + i++);
}
}
//2. 设置一个公开的方法停止线程,转换标志位
public void change01(){
flag = false;
System.out.println("run线程结束!");
}
public static void main(String[] args) {
StopDemo01 stopDemo01 = new StopDemo01();
new Thread(stopDemo01).start();
for (int i = 0; i < 1000; i++) {
if (i == 900){
stopDemo01.change01();
}
System.out.println("main线程正在运行···" + i);
}
}
}
2. 线程休眠
- sleep(时间)指定当前线程阻塞的毫米数(1s = 1000ms)
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时,倒计时等
- 每一个对象都有一个锁,sleep不会释放锁
package com.tyrant.lesson03;
import com.tyrant.lesson01.ThreadDemo04;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
//模拟网络延时 : 放大问题的发生性 --> com.tyrant.lesson01.ThreadDemo04.java
//模拟倒计时
public class Sleep01 implements Runnable {
@Override
public void run() {
}
//倒计时
public static void tenDown01() throws InterruptedException {
/*
for (int i = 10; i >= 0; i--) {
System.out.println(i);
Thread.sleep(1000);
}
System.out.println("结束!");
*/
//打印当前系统时间
while (true){
Thread.sleep(1000);
Date date = new Date(System.currentTimeMillis());//获取当前系统时间
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
}
}
public static void main(String[] args) throws InterruptedException {
tenDown01();
}
}
3. 线程礼让
- 礼让线程,让当前正在执行的线程暂停,但不阻塞
- 将县城从运行状态转为就绪状态
- 让cpu重新调度,而礼让不一定成功
package com.tyrant.lesson03;
//测试线程礼让
public class YieldDemo01 implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程开始运行");
Thread.yield();
System.out.println(Thread.currentThread().getName() + "线程停止运行");
}
public static void main(String[] args) {
YieldDemo01 yieldDemo01 = new YieldDemo01();
new Thread(yieldDemo01,"A").start();
new Thread(yieldDemo01,"B").start();
}
}
4. 线程强制执行
- join()合并线程,待此线程执行完成后再执行其他线程,其他线程阻塞
- 可以想象成插队
package com.tyrant.lesson03;
//测试join方法
//想象成插队
public class JoinDemo01 implements Runnable {
@Override
public void run() {
for (int i = 1; i <= 1000; i++) {
System.out.println( i +"-->学生来了");
}
}
public static void main(String[] args) throws InterruptedException {
//启动我们的线程
JoinDemo01 joinDemo01 = new JoinDemo01();
Thread thread1 = new Thread(joinDemo01);
thread1.start();
//主线程
for (int i = 1; i < 501; i++) {
if (i == 200){
thread1.join();
}
System.out.println(i + "-->main来了" );
}
}
}
4. 线程状态观测
- NEW:尚未启动的线程处于此状态
- RUNNABLE在java虚拟机中执行的线程处于此状态
- BLOCKED:被阻塞等待监视器的线程处于此状态
- WAITING:正在等待另一个线程执行特定动作的线程处于此状态
- TIMED_WAITING:正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
- TERMINATED:已退出的线程处于此状态
package com.tyrant.lesson03;
public class StateDemo01 {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
System.out.println(i);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("/////////");
});
//观察状态
Thread.State state = thread.getState();
System.out.println(state);
//启动线程
thread.start();
state = thread.getState();
System.out.println(state);
while (state != Thread.State.TERMINATED){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
state = thread.getState();
System.out.println(state);
}
}
}
5. 线程优先级priority
- java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程,线程调度器按照优先级决定应该调度哪个线程来执行
- 线程的优先级用数字表示,范围从1~10
- Thread.MIN_PRIORITY = 1;
- Thread.MAX_PRIORITY = 10;
- Thread.NORM_PRIORITY = 5;
- 使用以下方式改变或获取优先级
- setPriority(int xxx)
- getPriority()
package com.tyrant.lesson03;
//测试线程的优先级
public class PriorityDemo01 {
public static void main(String[] args) {
System.out.println(Thread.currentThread().getName() +
"-->" + Thread.currentThread().getPriority());
MyPriority01 myPriority01 = new MyPriority01();
Thread t1 = new Thread(myPriority01, "run1");
Thread t2 = new Thread(myPriority01, "run2");
Thread t3 = new Thread(myPriority01, "run3");
Thread t4 = new Thread(myPriority01, "run4");
Thread t5 = new Thread(myPriority01, "run5");
Thread t6 = new Thread(myPriority01, "run6");
//先设置优先级
t2.setPriority(3);
t3.setPriority(5);
t4.setPriority(7);
t5.setPriority(9);
//t6.setPriority(11);//IllegalArgumentException
t6.setPriority(10);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
}
}
class MyPriority01 implements Runnable{
@Override
public void run() {
//打印线程优先级
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +
"-->" + Thread.currentThread().getPriority());
}
}
优先级低只是意味着获得调度的概率低,并不是优先级低就不会被调用了,这都是看CPU的调度
4. 守护线程daemon
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如后台记录操作日志,监控内存,垃圾回收等待等
package com.tyrant.lesson03;
//测试守护线程
public class DaemonDemo01 {
public static void main(String[] args) {
God01 god = new God01();
YourLife01 you = new YourLife01();
Thread thread = new Thread(god);
thread.setDaemon(true);//默认false是用户线程,正常的线程都是用户线程
thread.start();
new Thread(you).start();
}
}
//God
class God01 implements Runnable{
@Override
public void run() {
while (true){
System.out.println("保佑你");
}
}
}
//你
class YourLife01 implements Runnable{
@Override
public void run() {
System.out.println("==hello world==");
for (int i = 0; i < 30000; i++) {
System.out.println("开心活着");
}
System.out.println("==good bye world==");
}
}
三、线程同步
1. 机制
并发:多个线程同时操作同一个资源
例子:上万人同时枪100张票,两个银行同时取钱
处理多线程问题时,多个线程访问同一个对象,并且某些线程还想修改这个对象,这时候我们就需要线程同步,线程同步其实就是一种等待机制,多个需要同时访问此对象的线程进入这个对象的等待池形成队列,等待前面线程使用完毕,下一个线程再使用
由于同一进程的多个线程共享同一块存储空间,在带来方便的同时,也带来了访问冲突问题,为了保证数据在方法中被访问时的正确性,在访问时加入锁机制synchronized,当一个线程获得对象的排他锁,独占资源,其他线程必须等待,使用后释放锁即可,存在以下问题:
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多线程竞争下,加锁,释放锁会导致比较多的上下文切换和调度延时,引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁,会导致优先级倒置,引起性能问题
2. 三个不安全案例
- 不安全买票
package com.tyrant.lesson04;
//不安全买票
public class UnsafeBuyTicketDemo01 {
public static void main(String[] args) {
ticket t1 = new ticket();
new Thread(t1,"张三").start();
new Thread(t1,"李四").start();
new Thread(t1,"黄牛").start();
}
}
class ticket implements Runnable{
private int tickets = 10;
boolean flag = true;//外部停止
@Override
public void run() {
//买票
while (flag){
try {
buy01();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//买票方法
private void buy01() throws InterruptedException {
if (tickets <= 0){
System.out.println("售空");
flag = false;
return;
}
//模拟延时
Thread.sleep(1000);
//买票
System.out.println(Thread.currentThread().getName() +
"-->拿到倒数第" + tickets-- + "张票");
}
}
- 不安全取钱
package com.tyrant.lesson04;
//不安全取钱
public class UnsafeBankDemo01 {
public static void main(String[] args) {
Account account = new Account("基金",100000);
new Drawing(account,50000,"张三").start();
new Drawing(account,60000,"李四").start();
}
}
//账户
class Account {
private String name;
private int money;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public Account(String name, int money) {
this.name = name;
this.money = money;
}
}
//银行:模拟取款
class Drawing extends Thread{
private Account account;//账户
private int drawingMoney;//取钱
private int handMoney;//现金
public Drawing(Account account, int drawingMoney, String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
@Override
public void run() {
//判断有没有钱
if (drawingMoney > account.getMoney()){
System.out.println("余额不足!");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//设置余额
int nowMoney = account.getMoney() - drawingMoney;
account.setMoney(nowMoney);
System.out.println(account.getName() + "卡里的余额为:" + nowMoney);
handMoney = handMoney + drawingMoney;
System.out.println(this.getName() + "手里的现金为:" + handMoney);
}
/*
基金卡里的余额为:40000
李四手里的现金为:60000
基金卡里的余额为:50000
张三手里的现金为:50000
线程不安全
*/
}
- 不安全集合
package com.tyrant.lesson04;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeListDemo01 {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()-> {
list.add(Thread.currentThread().getName());
}).start();
//不要忘了启动线程
}
//Thread.sleep(3000);
System.out.println(list.size());
}
}
3. 同步方法及同步块
由于我们可以通过private关键字来保证数据对象只能被方法访问,所以我们只需要针对方法提出一套机制,这套机制就是synchronized 关键字,它包括两种用法:synchronized 方法和synchronized 块
同步方法:public synchronized void method(int args){}
synchronized方法控制对“对象”的访问,每个对象对应一把锁,每个synchronized方法都必须获得调用该方法的对象的锁才能执行,否则线程会阻塞,方法一旦执行,就独占该锁,知道该方法返回才释放锁,后面被阻塞的线程才能获得这个锁,继续执行
缺陷:若将一个大的方法声明为synchronized,将会影响效率
- 方法里需要修改的内容才需要锁,锁的太多浪费资源
同步块:synchronized(Obj){}
Obj称之为同步监视器
- Obj可以是任何对象,但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器,因为同步方法的同步监视器就是this,就是这个对象本身,或者时class
同步监视器的执行过程
- 第一个线程访问,锁定同步监视器,执行其中代码
- 第二个线程访问,发现同步监视器被锁定,无法访问
- 第一个线程访问完毕,解锁同步监视器
- 第二个线程访问,发现同步监视器没有锁,然后锁定并访问
安全买票
package com.tyrant.lesson04;
//不安全买票
public class UnsafeBuyTicketDemo01 {
public static void main(String[] args) {
ticket t1 = new ticket();
new Thread(t1,"张三").start();
new Thread(t1,"李四").start();
new Thread(t1,"黄牛").start();
}
}
class ticket implements Runnable{
private int tickets = 10;
boolean flag = true;//外部停止
@Override
public void run() {
//买票
while (flag){
try {
buy01();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//买票方法
//synchronized 同步方法
private synchronized void buy01() throws InterruptedException {
if (tickets <= 0){
System.out.println("售空");
flag = false;
return;
}
//模拟延时
Thread.sleep(1000);
//买票
System.out.println(Thread.currentThread().getName() +
"-->拿到倒数第" + tickets-- + "张票");
}
}
安全取钱
package com.tyrant.lesson04;
//不安全取钱
public class UnsafeBankDemo01 {
public static void main(String[] args) {
Account account = new Account("基金",100000);
new Drawing(account,50000,"张三").start();
new Drawing(account,60000,"李四").start();
}
}
//账户
class Account {
private String name;
private int money;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public Account(String name, int money) {
this.name = name;
this.money = money;
}
}
//银行:模拟取款
class Drawing extends Thread{
private Account account;//账户
private int drawingMoney;//取钱
private int handMoney;//现金
public Drawing(Account account, int drawingMoney, String name){
super(name);
this.account = account;
this.drawingMoney = drawingMoney;
}
//取钱
//synchronized 默认锁this,但是要锁的是资源
@Override
public void run() {
//锁的对象是变化的量,需要增删改的对象
synchronized (account){
//判断有没有钱
if (drawingMoney > account.getMoney()){
System.out.println("余额不足!");
return;
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//设置余额
int nowMoney = account.getMoney() - drawingMoney;
account.setMoney(nowMoney);
System.out.println(account.getName() + "卡里的余额为:" + nowMoney);
handMoney = handMoney + drawingMoney;
System.out.println(this.getName() + "手里的现金为:" + handMoney);
}
}
}
安全集合
package com.tyrant.lesson04;
import java.util.ArrayList;
import java.util.List;
//线程不安全的集合
public class UnsafeListDemo01 {
public static void main(String[] args) throws InterruptedException {
List<String> list = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
new Thread(()-> {
synchronized (list){
list.add(Thread.currentThread().getName());
}
}).start();
//不要忘了启动线程
}
//防止主进程先走完
Thread.sleep(1000);
System.out.println(list.size());
}
}
4. 扩展JUC
package com.tyrant.lesson04;
import java.util.concurrent.CopyOnWriteArrayList;
//测试JUC安全类型的集合
public class JUCDemo01 {
public static void main(String[] args) {
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
for (int i = 0; i < 10000; i++) {
new Thread(() -> {
list.add(Thread.currentThread().getName());
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
5. Lock锁
- JDK5.0开始,Java提供了更强大的线程同步机制,通过显式定义同步锁对象来实现同步,同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象
- ReentrantLock 类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常见的是ReentrantLock,可以显式加锁,释放锁
package com.tyrant.lesson04;
import java.util.concurrent.locks.ReentrantLock;
public class LockDemo01 {
public static void main(String[] args) {
testLock01 testLock01 = new testLock01();
new Thread(testLock01).start();
new Thread(testLock01).start();
new Thread(testLock01).start();
}
}
class testLock01 implements Runnable{
private int tickets = 10;
private boolean flag = true;
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (flag){
buy();
}
}
private void buy() {
try {
lock.lock();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (tickets <= 0){
flag = false;
return;
}
System.out.println("剩余-->" + tickets + "-->票");
tickets --;
} finally {
lock.unlock();
}
}
}
synchronized和Lock的对比
- Lock是显式锁(手动开启和关闭锁,别忘记关闭锁)synchronized是隐式锁,出了作用域自动释放
- Lock只有代码块锁,synchronized有代码块锁和方法锁
- 使用Lock锁,JVM将花费较少的时间来调度线程,性能更好。并且具有更好的扩展性(提供更多的子类)
- 优先使用顺序
- Lock > 同步代码块(已经进入了方法体,分配了相应资源) > 同步方法(在方法体之外)
4. 死锁
多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情景,某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生死锁的问题
package com.tyrant.lesson05;
//死锁:多个线程互相抱着对方需要的资源,然后形成僵持
public class LockDemo01 {
public static void main(String[] args) {
Makeup aki = new Makeup(0, "aki");
Makeup kagami = new Makeup(1, "kagami");
aki.start();
kagami.start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
class Makeup extends Thread {
//需要的只有一份资源
private static Lipstick lipstick = new Lipstick();
private static Mirror mirror = new Mirror();
private int choice;//选择
private String name;//使用化妆品的人
public Makeup(int choice,String name){
this.choice = choice;
this.name = name;
}
@Override
public void run() {
//化妆
makeup();
}
//化妆,互相持有对方的锁,就是需要拿到对方的资源
private void makeup(){
/*
if (choice == 0){
synchronized (lipstick){
//获得口红的锁
System.out.println(this.name + "获得口红");
//然后想获得镜子
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (mirror){
System.out.println(this.name + "获得镜子");
}
}
} else if (choice == 1){
synchronized (mirror){
//获得镜子的锁
System.out.println(this.name + "获得镜子");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//然后想获得口红
synchronized (lipstick){
System.out.println(this.name + "获得口红");
}
}
}
*/
//破坏循环等待条件
if (choice == 0){
synchronized (lipstick){
//获得口红的锁
System.out.println(this.name + "获得口红");
}
//然后想获得镜子
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (mirror){
System.out.println(this.name + "获得镜子");
}
} else if (choice == 1){
synchronized (mirror){
//获得镜子的锁
System.out.println(this.name + "获得镜子");
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//然后想获得口红
synchronized (lipstick){
System.out.println(this.name + "获得口红");
}
}
}
}
产生死锁的四个必要条件:
- 互斥条件:一个资源每次只能被一个进程使用
- 请求与保持条件:一个进程因请求资源而阻塞时,对已获得的资源保持不放
- 不剥夺条件:进程已获得的资源,在未使用完之前,不能强行剥夺
- 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
- 只要想办法破坏其中任意一个或者多个条件就可以避免死锁发生
四、线程协作
1. 生产者消费者问题
场景:
- 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中中的产品取走消费
- 如果仓库中没有产品,则生产者将产品放入仓库,否则停止生产并等待,直到仓库中的产品被消费者取走为止
- 如果仓库中放有产品,则消费者可以将产品取走消费,否则停止消费并等待,直到仓库中再次放入产品为止
分析:这是一个线程同步问题,生产者和消费者共享同一个资源,并且生产者和消费者之间互相依赖,互为条件
- 对于生产者,没有生产产品之前,要通知消费者等待,而生产了产品之后,又需要马上通知消费者消费
- 对于消费者,在消费之后要通知生产者已经结束消费,需要生产新的产品以供消费
- 在生产者消费者问题中,仅有synchronized是不够的
- synchronized可阻止并发更新同一个共享资源,实现同步
- synchronized不能用来实现不同线程之间的消息传递(通信)
java提供了几个方法解决线程之间的通信问题
-
wait()
:表示线程一直等待,直到其他线程通知,与sleep不同,会释放锁 -
wait(long timeout)
:指定等待的毫秒数 -
notify()
:唤醒一个处于等待状态的线程 -
notifyAll()
:唤醒同一个对象上所有调用wait()方法的线程,优先级别高的线程优先调度
注意:均是Object类的方法,都只能在同步方法或者同步代码块中使用。否则会抛出异常
1. 管程法
package com.tyrant.lesson05;
//生产者消费者模型--> 利用缓冲区:管程法
//生产者,消费者,产品,缓冲区
public class PCDemo01 {
public static void main(String[] args) {
SynContainer synContainer = new SynContainer();
new P1(synContainer).start();
new C1(synContainer).start();
}
}
//生产者
class P1 extends Thread{
private SynContainer container;
public P1(SynContainer container){
this.container = container;
}
@Override
public void run() {
//生产一百个产品
for (int i = 1; i < 101; i++) {
container.push(new G1(i));
}
}
}
//消费者
class C1 extends Thread{
private SynContainer container;
public C1(SynContainer container){
this.container = container;
}
@Override
public void run() {
//消费一百个产品
for (int i = 1; i < 101; i++) {
G1 eat = container.pop();
}
}
}
//产品
class G1 {
private int id ;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public G1(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer{
//需要一个容器大小
private G1[] gs = new G1[10];
//容器计数器
private int count = 0;
//生产者放入产品
public synchronized void push(G1 g){
//如果容器满了,就需要等待消费者消费
if (count == gs.length ){
//通知消费者消费,生产者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果容器没满,生产者继续生产
gs[count] = g;
count++;
System.out.println("生产了-->" + g.getId() + "个产品");
//通知消费者消费
this.notifyAll();
}
//消费者消费产品
public synchronized G1 pop(){
//判断是否能消费
if (count == 0){
//等待生产者生产,消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//可以消费则消费
count--;
//原子操作,避免线程切换
System.out.println("消费了-->" + gs[count].getId() + "个产品");
//通知生产者生产
this.notifyAll();
return gs[count];
}
}
2. 信号灯法
package com.tyrant.lesson05;
//测试生产者消费
public class PCDemo02 {
public static void main(String[] args) {
TV tv = new TV();
//启动线程
new Player(tv).start();
new Watcher(tv).start();
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//生产者-->演员
class Player extends Thread{
TV tv;
public Player(TV tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
tv.play("节目-->" + (i+1));
}
}
}
//消费者-->观众
class Watcher extends Thread{
TV tv;
public Watcher(TV tv){
this.tv = tv;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
tv.watch();
}
}
}
//产品-->节目
class TV{
//演员表演,观众等待
//观众观看,演员等待
private String voice;
private boolean flag = false;
//表演
public synchronized void play(String voice){
//有节目则演员等待
if (flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("演员表演了:" + voice);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//通知观众观看
this.voice = voice;
//this.flag = !this.flag;
this.flag = true;
this.notifyAll();
}
//观看
public synchronized void watch(){
//无节目则观众等待
if (!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//观看
System.out.println("观众观看了:" + this.voice);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//this.flag = !this.flag;
this.flag = false;
//通知演员生产
this.notifyAll();
}
}
2. 线程池
背景:
- 经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大
思路:
- 提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中,可避免频繁创建销毁,实现重复利用,类似生活中的公共交通工具
好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于线程管理
- corePoolsize:核心池的大小
- maxmunPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
使用:
- JDK5.0提供了线程池相关的API:ExecutorService和Executors
- ExecutorService:真正的线程池接口,常见子类ThreadPoolExecutor
- void execute(Runnable command):执行任务/命令,没有返回值,一般用来执行Runnable
Future submit(Callable task):执行任务,有返回值,一般用来执行Callable - void shutdown():关闭连接池
- Executors:工具类、线程池的工厂类,用于创建并返回不同类型的线程池
package com.tyrant.lesson05;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class PoolDemo01 {
public static void main(String[] args) {
//1. 创建服务。创建线程池
//newFixedThreadPool 参数为:线程池大小
ExecutorService service = Executors.newFixedThreadPool(10);
service.execute(new MyThread01());
service.execute(new MyThread01());
service.execute(new MyThread01());
service.execute(new MyThread01());
service.shutdown();
}
}
class MyThread01 implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName() );
}
}