Java教程
Java从零开始 基础（五）线程同步和通信
本文主要是介绍Java从零开始 基础（五）线程同步和通信，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
线程同步
- 并发：同一个对象被多个线程同时操作
- 处理并发问题时，多个线程访问同一个对象，并且某些线程海鲜修改这个对象，这个时候就需要线程同步
- 线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用
- 线程同步 Synchronized：队列 + 锁
- 队列 Queue：数据结构，先进先出
- 锁 lock：保证数据安全。线程进来加上锁，执行完之后解锁，解锁后下一个线程进来
- 锁的缺点：影响性能
- 一个线程持有锁会导致其他所有需要此锁的线程被挂起
- 加锁/解锁 会导致比较多的上下文切换和调度延时
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置
不安全试例
没有加锁，线程不安全，会出现同一张票卖给两个不同的人
package com.syn;
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket buyTicket = new BuyTicket();
new Thread(buyTicket, "Jack").start();
new Thread(buyTicket, "Tom").start();
new Thread(buyTicket, "yellow cow").start();
}
}
class BuyTicket implements Runnable {
boolean flag = true; // 停止线程标志位
int ticket_nums = 0;
@Override
public void run() {
while (flag) {
try {
buy(); // 买票
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void buy() throws InterruptedException {
if (ticket_nums >= 10) {
return;
}
Thread.sleep(100);
System.out.println(Thread.currentThread().getName() + "拿到第 " + ticket_nums++ + " 张票");
}
}
/*
yellow cow拿到第 1 张票
Jack拿到第 3 张票
Tom拿到第 2 张票
Tom拿到第 4 张票
yellow cow拿到第 5 张票
Jack拿到第 4 张票
Tom拿到第 6 张票
yellow cow拿到第 6 张票
Jack拿到第 7 张票
Tom拿到第 8 张票
Jack拿到第 9 张票
yellow cow拿到第 8 张票
*/
Synchronized 线程锁
-
两种用法：synchronized方法 和 synchronized块
-
同步方法：public synchronized void method(int args){}
- synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方一旦执行，就独占改锁，知道该方法返回残释放锁，后面被阻塞的线程才能获得这个锁，继续执行
- 缺陷： synchronized 方法会影响效率。所以方法里需要修改内容时才需要锁
-
同步块：synchronized(Obj){}
- Obj 称之为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
-
同步监视器的执行过程
- 第一个线程访问，锁定同步监视器，执行其代码
- 第二个线程访问，发现同步监视器被锁定，无法访问
- 第一个线程访问完毕，解锁同步监视器
- 第二个线程访问，发现同步监视器未锁定，锁定并访问
package com.syn; public class SafeBuyTicket { public static void main(String[] args) { BuyTickets buyTicket = new BuyTickets(); new Thread(buyTicket, "Jack").start(); new Thread(buyTicket, "Tom").start(); new Thread(buyTicket, "yellow cow").start(); } } class BuyTickets implements Runnable { boolean flag = true; // 停止线程标志位 int ticket_nums = 1; @Override public void run() { while (flag) { try { buy(); // 买票 } catch (InterruptedException e) { e.printStackTrace(); } } } // synchronized 同步方法 public synchronized void buy() throws InterruptedException { if (ticket_nums >= 10) { return; } Thread.sleep(100); System.out.println(Thread.currentThread().getName() + "拿到第 " + ticket_nums++ + " 张票"); } } /* Jack拿到第 1 张票 Jack拿到第 2 张票 Jack拿到第 3 张票 Jack拿到第 4 张票 Jack拿到第 5 张票 Jack拿到第 6 张票 Jack拿到第 7 张票 Jack拿到第 8 张票 Jack拿到第 9 张票 */
死锁
多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，二导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题。
产生死锁的四个必要条件：
- 互斥条件：一个资源每次只能被一个进程使用。
- 请求与保持条件：一个进程因请求资源币阻塞时，对已茶得恣源保持不放。
- 不剥夺条件：进程已获得的资源，在末使用完之前，不能强行剥夺。
- 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。
package com.syn;
// 死锁：多个线程互相抢占对方需要的资源，形成僵持
public class DeadLock {
public static void main(String[] args) {
Makeup m1 = new Makeup(0,"Tom");
Makeup m2 = new Makeup(1,"Jack");
m1.start();
m2.start();
}
}
// 口红
class Lipstick{}
// 镜子
class Mirror{}
class Makeup extends Thread{
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;
String girlName;
Makeup(int choice, String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run() {
// 化妆
try {
makeUp();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 化妆，互相持有对方的锁，就是需要拿到对方需要的资源
private void makeUp() throws InterruptedException {
if (choice==0){
synchronized (lipstick){
System.out.println(this.girlName+" 获得口红的锁");
Thread.sleep(100);
synchronized (mirror){ // 100毫秒后想获得镜子
System.out.println(this.girlName+" 获得镜子的锁");
}
}
}else {
synchronized (mirror){
System.out.println(this.girlName+" 获得镜子的锁");
Thread.sleep(200);
synchronized (lipstick){
System.out.println(this.girlName+" 获得口红的锁");
}
}
}
}
}
Lock 锁
- 从JDK 5.0开始，Java提供了更强大的线程同步机制——通过业式定父同步锁对象来实现同步。同步锁使用Lock对象充当
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访门的工具。锁提供了对共享资源的独古访问，每次只能有一个线程对Lock对象加，线程开始访问共享资源之前应先获得Lock对象
- ReentrantLack 类实现了 Lock，它拥有与 sychronized 相同的并区性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock（可重入锁），可以显式加锁、释放锁。
synchronized 与 Lock 的对比
- Lock是显式锁（手动开启和关闭锁，别忘记关闭锁)，synchronized是隐或锁，出了作用域自动释放
- Lock只有代码块锁，synchronized有代码锁和方法锁
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有好的扩展性（提供更多的子类）
- 优先使用顺序：Lock＞同步代码块(已经进入了方法体，分配了相应资源）＞同步方法（在方法体之外）
package com.syn;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2).start();
new Thread(testLock2).start();
new Thread(testLock2).start();
}
}
class TestLock2 implements Runnable {
int ticket_num = 1;
// 定义Lock锁
private final ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
lock.lock(); // 加锁
if (ticket_num <= 10) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticket_num++);
} else {
break;
}
} finally {
lock.unlock(); // 解锁
}
}
}
}
线程通信
生产者消费者模式
是一个问题，并不是23中设计模式之一
应用场景：
- 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消赛者将仓库中产品取走消费．
- 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止．
- 如果仓库中放有产品，则消费者寸以將产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为业．
问题：
- 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件
- 对于生产者，没有生产产品之前，要通知消费者等待．而生产[产品之后，又需要马上通知消费者消费
- 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费．
- 在生产者消费者问题中，仅有synchronized是不够的：synchronized 可阻止并发更新同一个其享资源，实现了同步；
synchronized 不能用来实现不同线程之间的消息传递（通信）
方法：
- wait() 表示线程一直等待，直到其他线程通知，与sleep不同，该方法会释放锁
- wait(long timeout) 指定等待的毫秒数
- notify() 唤醒一个处于等待状态的线程
- notifyAll() 唤醒一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
- 均是Object类的方法，都只能用在同步方法或同步代码块中使用，否则会抛出：IllegaMonitorStateException
解决方式1：并发协作模型“生产者/ 消费者模式”->管程法
- 生产者：负责生产数据的模块(可能是方法，对象，线程，进程）
- 消费者：负责处理数据的模块（可能是方法，对象，线程，进程)
- 缓冲区：消费者不能直接使用生产者的数据，他们之间有个 缓冲区
- 生产者将生产好的数据放入缓冲区，消费者从缓冲区拿出数据
解决方式2：并发协作模型“生产者/消费者模式”…>信号灯法
管程法
package com.syn;
// 生产者消费者模型：利用缓冲区解决：管程法
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++) {
System.out.println("生产了" + i + " 只鸡");
try {
container.push(new Chicken(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; // 产品编号
public 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) {
// 通知消费者消费 生产者等待
this.wait();
}
// 如果没有满，就需要丢入产品
chickens[count] = chicken;
count++;
// 通知消费者消费 notifyAll()唤醒一个对象上所有调用wait()方法的线程
this.notifyAll();
}
// 消费者消费产品
public synchronized Chicken pop() throws InterruptedException {
// 判断能否消费
if (count == 0) {
// 等待生产者生产 消费者等待
this.wait();
}
// 如果可以消费
count--;
Chicken chicken = chickens[count];
// 吃完了 通知生产者生产
this.notifyAll();
return chicken;
}
}
信号灯法
package com.syn;
// 生产者消费者模型：利用标志位解决，信号灯法
public class TestPC {
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();
}
}
}
// 产品 节目
class TV {
// 演员表演 观众等待
// 观众观看 演员等待
String voice;
boolean flag;
// 表演
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;
}
}
线程池
背景：经常创建和销段、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
思路：提前创建好多个线程，放入线程涊中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公式交通工具。
好处：
- 提高响应速度 (减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
- corePoolSize：核心池的大小
- maximumPoolSize：最大线程数
- keepAliveTime： 线程没有任务时最多保持多长时间后会终止
使用：
- JDK 5.0起提体了线程池相关API：ExecutorService 和 Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
Future submit(Callablex task)：执行任务，有返回值，一般又来执行Callable - void shutdown() 关闭连接池
- Executors：工具类、线程池的工厂类，用于创建升返四太同类型的线程池
package com.syn;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPool {
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.execute(new MyThread());
// 关闭连接
service.shutdown();
}
}
class MyThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
这篇关于Java从零开始 基础（五）线程同步和通信的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
OpenFeign服务间调用学习入门12-27
-
OpenFeign服务间调用学习入门12-27
-
OpenFeign学习入门：轻松掌握微服务通信12-27
-
OpenFeign学习入门：轻松掌握微服务间的HTTP请求12-27
-
JDK17新特性学习入门：简洁教程带你轻松上手12-27
-
JMeter传递token学习入门教程12-27
-
JMeter压测学习入门指南12-27
-
JWT单点登录学习入门指南12-27
-
JWT单点登录原理学习入门12-27
-
JWT单点登录原理学习入门12-27
-
JWT解决方案学习入门：新手必读教程12-27
-
JWT解决方案学习入门：新手必读教程12-27
-
Mybatis持久层框架学习入门12-27
-
史上最全性能调优秘籍：让你的系统飞起来！12-27
-
Mybatis二级缓存学习入门详解12-27
栏目导航
