Java SE ——【多线程进阶知识】（一）

最新推荐文章于 2024-10-08 13:19:19 发布
最新推荐文章于 2024-10-08 13:19:19 发布
阅读量151 收藏
点赞数
分类专栏： Java SE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nigori_gjh/article/details/106088456
版权

线程的深入理解

多线程安全问题

  • 当多线程并发访问临界资源时，若破坏原子操作，可能会造成数据不一致。
    • 临界资源：共享资源(同一对象)，一次仅允许一个线程使用，才可保证其正确性。
    • 原子操作：不可分割的多步操作，被视作一个整体，其顺序和步骤不可打乱或缺省。

线程同步

（一）同步方式

1. 同步代码块
 synchronized (临界资源对象) { //对临界资源对象加锁
	 //代码(原子操作)
 }
  • 每个对象都有一个互斥锁标记，用来分配给线程。
  • 只有拥有对象互斥锁标记的线程，才能进入对该对象加锁的同步代码块。
  • 把同步代码块锁住，只让一个线程在同步代码块中执行。
  • 必须保证多个线程使用的锁对象是同一个。
  • 线程退出同步代码块时，会释放相应的互斥锁标记。
/**
 * 实现 Runnable 接口实现卖票安全机制
 * @author Nigori
 * @date 2020/8/2
 **/
public class Ticket implements Runnable {

    private int ticket = 100;

    private Object object = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (this) {       // 也可以是object，原因：始终只有一个对象
                if (ticket<=0) break;
                System.out.println(Thread.currentThread().getId() + ": " + Thread.currentThread().getName() + "卖了第 " + ticket + "张票！");
                ticket--;
            }
        }
    }
}
2. 同步方法
//对当前对象(this) 加锁即【 new Ticket() 】
修饰符 synchronized 返回值类型 方法名称(形参列表){
 	//代码(原子操作)
 }
  • 只有拥有对象互斥锁标记的线程，才能进入该对象加锁的同步方法中。
  • 线程退出同步方法时，会释放相应的互斥锁标记。
public class Ticket implements Runnable {

    private int ticket = 100;

    private Object object = new Object();
    @Override
    public void run() {
        while (true) {
            if (!sale()) {
                break;
            }
        }
    }

    public synchronized boolean sale() {  //锁对象为this  若为静态方法：锁对象为Ticket.class
        if (ticket<=0)
            return false;
        System.out.println(Thread.currentThread().getId() + ": " + Thread.currentThread().getName() + "卖了第 " + ticket + "张票！");
        ticket--;
        return true;
    }
}
3. 锁机制

位置： java.util.concurrent.locks

  • JDK 1.5加入，常用方法：
    • void lock() 获取锁，若锁被占用，则等待
    • boolean tryLock() 常数获取锁，成功返回true ，失败返回false ，不阻塞
    • void unlock() 释放锁
3.1 重入锁

ReentrantLock 类实现 Lock 接口，具有互斥性

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable {

    private int ticket = 10000;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();	//加锁
            try {
                if (ticket <= 0) break;
                System.out.println(Thread.currentThread().getName() + "卖了第" + ticket + "张票！");
                ticket--;
            } finally {
                lock.unlock();		//释放锁
            }
        }
    }
}
3.2 读写锁

ReentrantReadWriteLock 类实现 Lock 接口

一种支持一写多读的同步锁，读写分离，可分别分配读锁、写锁。支持多次分配读锁，使多个读操作可以并发执行。

  • 互斥规则
    • 写——写：互斥，阻塞。
    • 读——写：互斥，读阻塞写、写阻塞读。
    • 读——读：不互斥、不阻塞。
  • 在读操作远远高于写操作的环境中，可在保障线程安全的情况下，提高运行效率。
//import java.util.concurrent.locks.Lock;
**import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class RWLock {

    private String str;

    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();  //读写锁  用时：4013
    private ReentrantReadWriteLock.ReadLock readLock = rwl.readLock();
    private ReentrantReadWriteLock.WriteLock writeLock = rwl.writeLock();

    //private Lock lock = new ReentrantLock();        //互斥锁 用时：20103

	//读操作
    public String getValue() {
        readLock.lock();
        //lock.lock();
        try {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "读出的值为: " + str);
            return str;
        } finally {
            readLock.unlock();
            //lock.unlock();
        }
    }

	//写操作
    public void setValue(String str) {
        writeLock.lock();
        //lock.lock();
        try {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "写入的值为: " + str);
            this.str = str;
        } finally {
            writeLock.unlock();
            //lock.unlock();
        }
    }
}
3.3. 死锁
  • 当第一个线程拥有A对象锁标记，并等待B对象锁标记，同时第二个线程拥有B对象锁标记，并等待A对象锁标记时，产生死锁。
  • 一个线程可以同时拥有多个对象的锁标记，当线程阻塞时，不会释放已经拥有的锁标记，由此可能造成死锁。

@Example：

public class TeamWork {

    public static Object thingsA = new Object();
    public static Object thingsB = new Object();
}

public class RunnablDeathLockDemo {

    public static void main(String[] args) throws InterruptedException {
        Runnable personA = new Runnable() {
            @Override
            public void run() {
                synchronized (TeamWork.thingsA) {
                    System.out.println("A拿到了thingsA");
                    synchronized (TeamWork.thingsB) {
                        System.out.println("A拿到了thingsB");
                        System.out.println("A可以完成整个things");
                    }
                }
            }
        };

        Runnable personB = new Runnable() {
            @Override
            public void run() {
                synchronized (TeamWork.thingsB) {
                    System.out.println("B拿到了thingsB");
                    synchronized (TeamWork.thingsA) {
                        System.out.println("B拿到了thingsA");
                        System.out.println("B可以完成整个things");
                    }
                }
            }
        };

        Thread pa = new Thread(personA);
        Thread pb = new Thread(personB);

        pa.start();
        Thread.sleep(200);	//解决死锁
        pb.start();
    }
}

（二）线程通信

public class BankCard {

    private double money;
    private boolean flag;       //true:只能取  false：只能存

    public synchronized void addMoney(double m) {
        while (flag) {
            try {
                this.wait();  //进入等待队列，同时释放锁和CPU
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money = money + m;
        System.out.println(Thread.currentThread().getName() + "存了" + m + "元，余额是：" + money);
        flag = true;
        this.notifyAll();
    }

    public synchronized void takeMoney(double m) {
        while (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        money = money - m;
        System.out.println(Thread.currentThread().getName() + "取了" + m + "元，余额是：" + money);
        flag = false;
        this.notifyAll();
    }
}
1. 等待(java.lang.Object)

public final void wait(long timeout)

  • 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
2. 通知(java.lang.Object)

public final native void notify();

  • 唤醒在此对象监视器上等待的单个线程。

public final native void notifyAll();

  • 唤醒在此对象监视器上等待的所有线程。

（三）Callable接口

 public interface Callable<V> {
 	 public V call() throws Exception; 
 }
  • JDK5加入，与Runnable接口类似，但是 Callable具有泛型返回值、可以声明异常， 实现之后代表一个线程任务。
public class CallableDemo {

    public static void main(String[] args) throws Exception {

        //创建Callable对象
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum+=i;
                }
                return sum;
            }
        };
        //把Callable对象转换成可执行任务
        FutureTask<Integer> futureTask = new FutureTask<>(callable);

        //创建线程
        Thread thread = new Thread(futureTask);

        //启动线程
        thread.start();
        //获取结果（等待call执行完毕才会返回结果）
        System.out.println("1~100的求和结果为：" + futureTask.get());;
    }
}

（四）Future接口

  • V get()以阻塞形式等待Future中的异步处理结果，即call()的返回值
public class PoolSumDemo_01 {

    public static void main(String[] args) throws Exception {
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(1);

        //提交任务  Future:表示将要执行完任务的结果
        Future<Integer> future = executorService.submit(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 0; i <= 100; i++) {
                    sum+=i;
                }
                return sum;
            }
        });

        //获取结果：等待任务执行完毕才会返回
        System.out.println("使用Future，一个线程求0~100和结果为：" + future.get());

        //关闭线程池
        executorService.shutdown();
    }
}

（五）线程同步

形容一 次方法调用，同步一旦开始，调用者必须等待该方法返回，才能继续。

在这里插入图片描述

（六）线程异步

形容一次方法调用，异步一旦开始，像是一次消息传递，调用者告知之后立刻返回。二者竞争时间片，并发执行。

在这里插入图片描述

Convallaria@GJH
关注
专栏目录
Java SE ——【多线程进阶知识】）（二）
Nigori_gjh的博客
08-04 206
线程的深入理解一、线程池1. 创建池原因2. 创建线程池二、线程安全的集合1. List集合 + Queue队列（1）List集合（2）Queue接口（队列）ConcurrentLinkedQueueBlockingQueue接口（阻塞队列）2. Set集合3. Map集合 一、线程池 1. 创建池原因 问题 ● 线程是宝贵的内存资源、单个线程约占1MB空间，过多分配易造成内存溢出。 ● 频繁的创建及销毁线程会增加虚拟机回收频率、资源开销，造成程序性能下降。 线程池 ● 线程容器，可设定线程分配的数量上限。
Java SE ——【多线程基础知识】
Nigori_gjh的博客
03-21 210
一、概述 要学好多线程，先来了解三个名词概念 程序、进程、线程 什么是程序？ 程序（Program）是一个静态的概念，是一组计算机能识别和执行的指令（可执行文件），运行于电子计算机上，满足人们某种需求的信息化工具。 什么是进程？ 进程（Process）是一个动态的概念，一个具有独立功能的程序关于某个数据集合的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设...
JavaSE进阶（一）——多线程概述
老程的小白博客空间
11-24 400
JavaSE进阶（一）——多线程概述 前言 从本篇笔记开始我们进入到JavaSE进阶阶段的笔记记录，具体记录顺序是：多线程、集合、网络编程、注解和反射、GUI（简单记录）。当这些记录完毕后会开始JavaWeb方面的记录。 文章目录JavaSE进阶（一）——多线程概述前言多线程概述进程线程线程使用线程创建Thread类Runnable接口线程等待实现Callable接口（了解即可）总结 多线程概述 多线程就是一心多用，我们在日常的时候可以同时处理很多事。一边吃饭、一边刷剧；一边做家务，一边唱歌。其实在计算机中
Java基础进阶——多线程与JUC（上）
尼尧Nier的博客
06-05 912
最近在准备面试，把知识点复习一遍，整理出的笔记记录下，里面会穿插代码和面试例题。 内容不是原创，是总结和收集，并在理解的基础上进行一些完善，如果侵权了请联系作者，若有错误也请各位指正。因为收集的时候忘记把来源记录下来了，所以就不po出处了，请见谅（这是个坏习惯，一定改）。 Java基础进阶——JUC多线程多线程 这是面试复习内容的第十三篇——多线程，主要是Java基础的内容，所有内容将分为几篇来写。 多线程 ...
Java SE 学习记录——进阶版05
weixin_42690266的博客
02-01 116
@学习记录 开始学习Java 遵从同学的指导，从Java se开始学习 黑马的JavaSE零基础入门【异常、线程】 第一章 异常 1.1 异常概念 16-01 Map集合概述 1.2 异常体系 1.3 异常的产生过程解析 第二章 异常的处理 2.1 抛出异常throw 2.2 Objects非空判断 2.3 声明异常throws 2.4 捕获异常try…catch 2.4 finally代码块 2.5 异常注意事项 第三章 自定义异常 3.1 概述 3.2 自定义异常的练习 第四章 多线程 4.1 并发与并
Java SE 学习记录——进阶版12
weixin_42690266的博客
03-04 191
@学习记录 开始学习Java 遵从同学的指导，从Java se开始学习 黑马的JavaSE零基础入门【函数式接口】 第一章 函数式接口 1.1 概念 23-02 软件结构
Java SE 学习记录——进阶版11
weixin_42690266的博客
03-02 163
@学习记录 开始学习Java 遵从同学的指导，从Java se开始学习 黑马的JavaSE零基础入门【网络编程】 第一章 网络编程入门 1.1 概述 22-02 缓冲流得原理
Java SE 学习记录——进阶版03
weixin_42690266的博客
01-20 142
@学习记录 开始学习Java 遵从同学的指导，从Java se开始学习 黑马的JavaSE零基础入门【List、Set、数据结构、Collections】 第一章 数据结构 1.1 数据结构有什么用 1.2 常见的数据结构 栈 队列 数组 链表 红黑树 day14-02 数据结构_栈（先进后出） day14-03 数据结构_队列（先进先出） day14-04 数据结构_数组（查询快，增删慢） day14-05 数据结构_链表（查询慢，增删快） 　　感觉视频关于单向链表和双向链表的解释并没有很清
Java进阶八—多线程
2301_76556912的博客
12-21 980
1.一台计算机为何能够执行多个程序？它们是怎么执行多个程序的？电脑可以同时做很多事情，一边聊天，一边听歌，一边上网查资料等，原因是电脑有多个核心(脑子)，一个核心可以做一件事情，多个核心就可以做多件事情。而在很早的时候计算机CPU只有一个核心只能处理一件事情，所以科学家想出了一个办法，假如有两个应用，一个应用不使用时可将这个应用暂停(挂起)，使用时打开将另一个应用暂停(挂起)。造成一种假象表面上CPU可以同时运行两个程序，实际上是进程切换的快，第一个进程打开，第二个进程挂起，给你一种错觉。得出：多核CPU可
java类库——中文版
03-17
- runnable接口：这是一个函数式接口，用于声明一个run方法，可以实现多线程编程。 - Cloneable接口：这个接口指示一个类的实例可以被克隆。 6. Java基础类： - Boolean类：表示基本数据类型boolean的包装类。 ...
【Java基础知识 1】Java入门级概述
热门推荐
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
深入理解Java虚拟机——Java虚拟机介绍——第一章
qq_44891295的博客
02-14 4096
文章目录1：Java虚拟机的介绍2：JVM的存在位置3：JVM整体结构4：Java代码执行流程5：JVM指令集的架构模型6：JVM的生命周期7：常见的Java虚拟机7.1 Sun Classic VM7.2 Exact VM7.3 HotSpot VM 1：Java虚拟机的介绍 Java虚拟机的介绍 1： Java虚拟机是一台执行Java字节码的虚拟计算机，它拥有独立的运行机制，其运行的Jav...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 914
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 342
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1010
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 697
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
==与equals比较
最新发布
suuijbd的博客
10-08 375
在JVM中，内存分为堆内存跟栈内存。他们二者的区别是： 当我们创建一个对象（new Object）时，就会调用对象的构造函数来开辟空间，将对象数据存储到堆内存中，与此同时在栈内存中生成对应的引用，当我们在后续代码中调用的时候用的都是栈内存中的引用。还需注意的一点，基本数据类型是存储在栈内存中。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 510
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值