Java多线程
2020-03-27 本文已影响0人
忒无聊了叭
线程简介
初识
程序
说起进程，就不得不说程序，程序是指令和数据的有序集合，其本身没有任何意义，是一个静态的概念。
进程
进程就是执行程序的一次过程，他是一个动态的概念，是系统资源分配的单位。
线程
通常在一个进程中，可以包含多个线程，一个进程中至少存在一个线程，不然没有存在的意义，线程是cpu调度和执行的单位。
注意:很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核。
举例：比如说一边玩游戏，一边听音乐是同时进行的吗?
不是。因为单CPU在某一个时间点上只能做一件事情。
而我们在玩游戏，或者听音乐的时候，是CPU在做着程序间的高效切换让我们觉得是同时进行的。
创建线程的三种方式
创建线程的三种方式.png
继承thread类进行实现多线程
package com.szw;
//创建线程方式一：继承thread，重新run()方法，调用start()开启线程
public class Thread01 extends Thread {
@Override
public void run() {
//run方法线程体,重写父类run方法
for (int i = 0; i < 200; i++) {
System.out.println("我在看代码~~"+i);
}
}
public static void main(String[] args) {
//main主线程
Thread01 thread01 = new Thread01();
//调用start方法，启动多线程
thread01.start();
for (int i = 0; i < 200; i++) {
System.out.println("我在学习多线程~~"+i);
}
}
}
问题：启动线程为什么不直接使用run方法，而是start方法?
Thired类用于描述线程，其中有一个定义存储功能run，用于存储线程要运行的代码，主线程的代码在main中，新线程的代码在run中，start除了开启新线程之外，还有就是启动线程的功能。
实现runnable进行多线程
package com.szw;
//创建线程方式2：实现runnable接口，重新run方法
public class Thread02 implements Runnable {
@Override
public void run() {
//run方法线程体
for (int i = 0; i < 200; i++) {
System.out.println("我在看代码~~" + i);
}
}
public static void main(String[] args) {
Thread02 thread02 = new Thread02();
//创建线程对象，通过线程对象来开启我们的线程，代理
new Thread(thread02).start();
for (int i = 0; i < 200; i++) {
System.out.println("我在学习多线程~~" + i);
}
}
}
以上两种方式，查看源码可知，thread也是实现了runnable接口，由于java单继承的特性，所以推荐使用runnable进行多线程。
上面两种开启时的区别是：runnable是需要放在Thread中进行start，而thread直接开启即可。
模拟龟兔赛跑
Thread.currentThread表示当前代码段正在被哪个线程调用的相关信息。
package com.szw;
//模拟龟兔赛跑
public class Race implements Runnable{
//胜利者
private static String winner;
@Override
public void run() {
//如果是兔子线程，模拟睡觉
if (Thread.currentThread().getName().equals("兔子")){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
for (int i = 1 ;i <= 100; i++) {
//判断比赛是否结束
boolean b = gameOver(i);
if (b){
break;
}
System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
}
}
public boolean gameOver(int steps){
//判断是否有胜利者
if (winner!=null){//这里是因为两个进程，一个进程胜利之后，另一个还在跑
return true;
}else {
if (steps>=100){
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();
}
}
扩展：Lambda表达式
官方定义：Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
由于runnable接口就是函数式接口，所以我们这里扩展Lambda可以让代码更简洁。
package com.szw;
//Lambda表达式
public class Lambda {
//第二种方法：静态内部类
static class Love implements ILove{
@Override
public void ILove(int a) {
System.out.println("I Love you 序号2"+a);
}
}
public static void main(String[] args) {
//第三种方法：局部内部类
class Love implements ILove{
@Override
public void ILove(int a) {
System.out.println("I Love you 序号3"+a);
}
}
//第四种方法：匿名内部类
ILove love = new Love(){
@Override
public void ILove(int a) {
System.out.println("I Love you 序号4"+a);
}
};
//第五种方法Lambda表达式
ILove love2 = (int a) -> {
System.out.println("I Love you 序号5"+a);
};
//简化一:简化Lambda表达式
ILove love3 = (a) -> {
System.out.println("I Love you 序号6"+a);
};
//简化二:去掉a的括号，继续简化Lambda表达式
ILove love4 = a -> {
System.out.println("I Love you 序号7"+a);
};
//简化三：去掉花括号，(注意这里只是一行代码的情况)继续简化Lambda表达式
ILove love5 = a -> System.out.println("I Love you 序号8"+a);
//Lambda表达式：
//前提：1、只有一行代码，否则使用代码块包裹。
//2、必须是函数式接口，接口中只有一个方法
//3、多个参数也可以去掉int，但是要加括号
love.ILove(0);
love2.ILove(0);
love3.ILove(0);
love4.ILove(0);
love5.ILove(0);
}
}
//第一种方法：首先定义一个接口，实现它，然后在主方法中进行调用（普通的方法）
interface ILove{
void ILove(int a);
}
class Love implements ILove{
@Override
public void ILove(int a) {
System.out.println("I Love you 序号1"+a);
}
}
线程状态
线程的状态.png
注意：查看源码，可知线程有六种状态！
线程的一些方法：
线程停止
线程停止
1、建议线程停止--->利用次数，不建议死循环
2、建议使用标志位--->设置一个标志位
3、不建议使用stop和destroy等过时的方法，jdk官方不推荐
package com.szw;
//测试线程停止
//1、建议线程停止--->利用次数，不建议死循环
//2、建议使用标志位--->设置一个标志位
//3、不建议使用stop和destroy等过时的方法，jdk官方不推荐
public class ThreadStop implements Runnable {
//设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while (flag) {
System.out.println("run...+Thread" + i++);
}
}
//设置一个公开的标志位
public void stop() {
this.flag = false;
}
public static void main(String[] args) {
ThreadStop threadStop = new ThreadStop();
new Thread(threadStop).start();//线程开始
for (int i = 0; i < 200; i++) {
System.out.println("主线程" + i);
if (i == 100) {
//调用stop方法，停止
threadStop.stop();
System.out.println("线程停止...");
}
}
}
}
线程休眠
模拟时钟思路：首先获取系统时间，然后进行while循环，输出系统时间，线程休眠1s，然后更新获取系统时间，再输出。。
package com.szw;
import java.text.SimpleDateFormat;
import java.util.Date;
//线程休眠模拟倒计时
public class TestSleep {
public static void main(String[] args) {
Date startTime = new Date(System.currentTimeMillis());//获取系统时间
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
startTime = new Date(System.currentTimeMillis());//更新时间
}
}
//模拟倒计时
public static void tenDown() throws InterruptedException {
int num = 10;
while (true) {
Thread.sleep(1000);
System.out.println(num--);
if (num < 0) {
break;
}
}
}
}
线程礼让
- 线程礼让，让当前的线程暂停，但是不堵塞。
- 将线程的运行状态重新定义为就绪状态。
- 相当于让cpu重新调度，但是礼让不一定成功！看cpu
详细解释
yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”，从而让其它具有相同优先级的等待线程获取执行权；但是，并不能保证在当前线程调用yield()之后，其它具有相同优先级的线程就一定能获得执行权；也有可能是当前线程又进入到“运行状态”继续运行！
举个例子：一帮朋友在排队上公交车，轮到Yield的时候，他突然说：我不想先上去了，咱们大家来竞赛上公交车。然后所有人就一块冲向公交车，有可能是其他人先上车了，也有可能是Yield先上车了。
线程强制执行
- Join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
- 类似于插队，让被强制执行的线程执行完毕后，才可以允许其他线程进行。
package com.szw;
public class ThreadJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println("线程插队"+i);
}
}
public static void main(String[] args) throws InterruptedException {
ThreadJoin threadJoin = new ThreadJoin();
Thread thread = new Thread(threadJoin);
thread.start();
//主线程
for (int i = 0; i < 500; i++) {
if (i==200){
thread.join();//强行让线程执行
System.out.println("线程执行完毕，主线程才开始~~~~~~~~~~~~~~~~~~~~~~~");
}
System.out.println("主线程"+i);
}
}
}
线程状态
- NEW
尚未启动线程处于此状态。
- Runnable
在Java虚拟机中执行的线程处于此状态。
- BLOCKED
被阻塞监视等待锁定的线程，就处于此状态。
- WAITING
正在等待另一个线程执行特定动作的线程处于此状态。
- TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
- TERMINATED
已经退出的线程处于此状态；
package com.szw;
//线程状态
public class ThreadState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(()->{//这里的意思就是让线程运行5s
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} 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.getState().TERMINATED){//线程状态不是停止的时候
for (int i = 0; i < 5; i++) {
thread.sleep(1000);//每隔一秒输出线程的状态
state = thread.getState();
System.out.println(state);
}
}
System.out.println("线程停止~~~");
}
}
线程优先级
优先级具有随机性：一般优先级较高的线程先执行run()方法，但是这个不能说的但肯定，因为线程的优先级具有 “随机性”也就是较高线程不一定每一次都先执行完。
package com.szw;
//线程优先级
public class ThreadPriority {
public static void main(String[] args) {
//主线程
System.out.println("main"+"-->"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
t1.setPriority(2);//2
t2.setPriority(3);//3
t3.setPriority(Thread.NORM_PRIORITY);//5
t4.setPriority(Thread.MAX_PRIORITY);//10
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
}
}
守护线程daemon
- 线程分为用户线程和守护线程
- 虚拟机必须保护用户线程完成
- 虚拟机不用等待守护线程完毕
通俗易懂的就是说：守护线程是维护用户线程的，等用户线程跑完之后，守护线程也会停止。
package com.szw;
public class ThreadDaemon {
public static void main(String[] args) {
Gad gad = new Gad();
You you = new You();
Thread thread = new Thread(gad);
thread.setDaemon(true);
thread.start();
//启动你
new Thread(you).start();
}
}
class You implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("快乐的每一天~~"+i);
}
}
}
class Gad implements Runnable{
@Override
public void run() {
while (true){
System.out.println("上帝保护你~~");
}
}
}
多线程暴露的问题
三人买票问题
使用多线程三人买票，运行输出发现票的数据严重不正确。
package com.szw;
public class Thread03 implements Runnable {
//定义票数有10张
private int ticketNums = 10;
@Override
public void run() {
while (true) {
if (ticketNums <= 0) {
break;
}
//模拟延时
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums + "票");
ticketNums--;
}
}
public static void main(String[] args) {
Thread03 thread03 = new Thread03();
new Thread(thread03, "小明").start();
new Thread(thread03, "小孩").start();
new Thread(thread03, "黄牛党").start();
}
}
1585112453859.png
银行取钱问题
我和妻子同时取钱：出现错误。
package com.szw;
import com.sun.org.apache.bcel.internal.generic.NEW;
public class UnSafeBank {
public static void main(String[] args) {
//账户
Account account = new Account(100,"结婚基金");
new Drawing(account,100,"你").start();
new Drawing(account,100,"妻子").start();
}
}
//账户
class Account{
int money;
String name;
public Account(int money, String name) {
this.money = money;
this.name = name;
}
}
//银行
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(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//卡内的余额 = 余额 - 你取的钱
account.money = account.money - drawMoney;
//你手里的钱
nowMoney = nowMoney + drawMoney;
System.out.println(account.name+"余额为"+account.money);
System.out.println(this.getName()+"手里的钱"+nowMoney);
System.out.println(account.name+"余额为"+account.money);
System.out.println("------------------------------");
}
}
}
同时取钱问题.png
线程同步
同修饰私有属性的关键词private一样，线程同步也有修饰词synchronized，加上该修饰词后，只允许一个对象去操作，每个对象有一把锁，当对象访问时，把锁加上，后面的进程就会形成阻塞。
synchronized有synchronized方法，和synchronized块。
缺陷：若将一个大的方法申明为synchronized将会影响效率。
注意：synchronized块的使用方法是：
synchronized(obj){
//这里的obj是需要锁的对象，为增删改的对象
}
我们在上面的取钱的问题上加上，synchronized修饰，问题就修改了。
取钱修改.png
synchronized方法上使用的是：
private synchronized void buy(){
}
//这里不需要指明被锁的对象，默认是this，就是这个方法的对象本身
死锁
解释： 多个线程各自占有一些共享资源,并且互相等待其他线程占有的资源才能运行,而导致两个或者多个线程都在等待对方释放资源,都停止执行的情形.某一个同步块同时拥有“两个以上对象的锁”时,就可能会发生“死锁”的问题。
通俗的讲：就是两个线程运行时，都需要对面的资源进行完成指令，但是都等待对方的资源释放，从而形成停止执行的情况。
package com.szw;
public class DeadLock {
public static void main(String[] args) {
Makeup makeup = new Makeup(0,"白雪公主");
Makeup makeup1 = new Makeup(1,"灰姑娘");
makeup.start();
makeup1.start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
class Makeup extends Thread{
int choice;//选择
String girlName;//姓名
Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
//化妆需要的镜子和口红都只有一份
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
@Override
public void run() {
makeup();
}
private void makeup(){
if (choice == 0){
synchronized (lipstick){
System.out.println(this.girlName+"获得了口红");
synchronized ((mirror)){
System.out.println(this.girlName+"获得了镜子");
}
}
}else {
synchronized (mirror){
System.out.println(this.girlName+"获得了镜子");
synchronized ((lipstick)){
System.out.println(this.girlName+"获得了口红");
}
}
}
}
}
可以运行代码，发现两个对象都没有继续获得镜子或者口红，这里修改的方法就是，分别把0获取镜子的线程同步方法分开。1的口红与镜子分开。这样实现了两个对象不会产生抱死的状态。
Lock
和synchronized功能一样。
这里写一下加lock锁以后的取票问题，注意的是用lock锁有加锁解锁的过程，写在try...finally...中
package com.szw;
import java.util.concurrent.locks.ReentrantLock;
public class UnSafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket,"我").start();
new Thread(buyTicket,"你").start();
new Thread(buyTicket,"黄牛党").start();
}
}
class BuyTicket implements Runnable{
private ReentrantLock lock = new ReentrantLock();
private int ticketNum = 10;
boolean flag = true;
@Override
public void run(){
while (true){
try {
buy();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
privatevoid buy() throws InterruptedException {
try {
lock.lock();//加锁
//判断是否有票
if (ticketNum<=0){
flag = false;
return;
}
//模拟买票
Thread.sleep(100);
//拿到票
System.out.println(Thread.currentThread().getName()+"拿到"+ticketNum--);
}finally {
//解锁
lock.unlock();
}
}
}
线程协作
线程通信
生产消费者模式
生产消费者.png
package com.szw;
//测试：生产者消费者模型->利用缓冲区解决：管程法
//生产者、消费者、产品、缓冲区
public class TestPc {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start();
new Consumer(container).start();
}
}
//生产者
class Producer extends Thread {
//缓冲区
SynContainer container;
public Producer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
container.push(new Chicken(i));
System.out.println("生产了" + i + "只鸡");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//消费者
class Consumer extends Thread {
SynContainer container;
public Consumer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
System.out.println("消费了-->" + container.pop().id + "");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//产品
class Chicken {
int id;
Chicken(int id) {
this.id = id;
}
}
//缓冲区
class SynContainer {
//需要一个容器大小
Chicken[] chickens = new Chicken[10];
int Count = 0;
//生产者放入产品
public synchronized void push(Chicken chicken) throws InterruptedException {
if (Count == chickens.length) {
//如果有10只鸡，就先停止生产，让消费者消费
this.wait();
}
chickens[Count] = chicken;
Count++;
//通知消费者消费
this.notifyAll();
}
//消费者消费产品
public synchronized Chicken pop() throws InterruptedException {
if (Count == 0) {
//通知生产者生产，先停止消费
this.wait();
}
//有鸡：就进行消费
Count--;
Chicken chicken = chickens[Count];
this.notifyAll();//唤醒全部线程
return chicken;
}
}
1585317414956.png
package com.szw;
//测试生产消费者问题2：信号灯法，标志位解决
public class TestPc2 {
public static void main(String[] args) {
TV tv = new TV();
new Player(tv).start();
new Watcher(tv).start();
}
}
//表演者
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 % 2 == 0) {
this.tv.play("快乐大本营。。。");
} else {
this.tv.play("广告中。。。");
}
}
}
}
//消费者
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();
}
}
}
//产品，TV
class TV {
//演员表演，观众等待
//观众观看，演员等待
String voice;
boolean flag = true;//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;
}
}
线程池
背景:经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。
思路:提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处:
◆提高咆应速度(减少了创建新线程的时间)
◆降低资源消耗(重复利用线程池中线程,不需要每次都创建）
◆便于线程管理
