Java多线程学习笔记（三）

最新推荐文章于 2024-09-27 00:45:01 发布
最新推荐文章于 2024-09-27 00:45:01 发布
阅读量107 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AHawkeye/article/details/116426019
版权

多线程 java

同步方法解决实现Runnable的线程安全问题

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明为同步的。

package com.xzc;

class Window3 implements Runnable {
    public Window3() {
    }

    private int ticket;

    public Window3(int ticket) {
        this.ticket = ticket;
    }

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private synchronized void show() {
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "卖票，票号为：" + ticket--);
        }
    }
}

public class Test3 {
    public static void main(String[] args) {
        Window3 w = new Window3(100);
        new Thread(w, "窗口一").start();
        new Thread(w, "窗口二").start();
        new Thread(w, "窗口三").start();
    }

}

输出结果：
在这里插入图片描述
注意这里：private synchronized void show()就是同步方法处理。
这里的锁没有显示出来，但是也是有锁，在show方法里，锁就是this。

同步方法解决继承Thread的线程安全问题

此时不能像之前一样，直接把show方法定义为synchronized的，因为锁的不唯一。如果非想用同步方法解决，就要在synchronized前面加一个static声明为静态方法。

package com.xzc;

class Window4 extends Thread {
    public Window4() {

    }

    public Window4(String name) {
        super(name);
    }

    private static int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
    private static synchronized void show(){
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket--);
        }
    }
}

public class Test4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4("窗口一");
        Window4 w2 = new Window4("窗口二");
        Window4 w3 = new Window4("窗口三");
        w1.start();
        w2.start();
        w3.start();
    }

}

输出结果：
在这里插入图片描述
此时，我们的锁是当前类，Window4.class

同步方法总结

同步方法仍然涉及到锁，只是不需要我们显示声明

非静态的同步方法，同步监视器是this

静态的同步方法，同步监视器是当前类本身（即Class类对象）

线程安全的单例模式之懒汉式

package demo01;

public class BankTest {

}

//懒汉式
class Bank{
    private Bank(){}
    private static Bank instance = null;
    public static  Bank getInstance(){
        if (instance == null){
           instance = new Bank();   
        }
        return instance;
    }
}

这样是不线程安全的，如果我们有多个线程run方法调用getInstance方法，其中一个线程进来，首次instance肯定是null，然后刚进if语句，可能会被阻塞，即使不被阻塞，cpu也可能切换到线程2，另外一个线程进来，那么instance会先后两次赋值，显然是不对的，因为instance是静态Bank类型变量。instance相当于是共享数据了。下面用同步方式修改为线程安全的：

package demo01;

public class BankTest {

}

//懒汉式
class Bank{
    private Bank(){}
    private static Bank instance = null;
    public static  Bank getInstance(){
        //方式一：效率稍差
        /*synchronized(Bank.class) {
            if (instance == null) {
                instance = new Bank();
            }
            return instance;
        }*/
        //方式二
        if (instance == null){
            synchronized (Bank.class){
                if(instance == null) {
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

我们先看方式一，return如果在synchronized同步代码块里面，为什么效率会低，这是因为不管instance是不是null，都进入同步代码块，如果线程非常多，就会产生效率低下问题，假设线程一拿到锁，产生一个instance返回，后面的所有线程还要在同步代码块前面等着，事实上这是无意义的，因为我们已经有instance了，后面的线程拿着instance返回就好了。而方式二就修正了这个问题，我们在同步代码块面前先判断instance是不是空，并且把return instance提出来，这样线程一二三可能在同步代码块中抢一下锁，卡一会，但是后面的所有线程进来，直接就判断instance不是null了，然后直接返回instance就好了。
这样我们就把单例模式的懒汉式修改为线程安全的了。

线程死锁

在这里插入图片描述
当我们有两个锁嵌套的时候，就比较容易出现死锁问题：

package demo01;

public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(() -> {
            synchronized (s2) {
                s1.append("c");
                s2.append("3");
                
                synchronized (s1) {
                    s1.append("d");
                    s2.append("4");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }).start();
    }
}

输出结果
在这里插入图片描述
这段代码其实就有死锁隐患，这是线程顺次执行完了，我们用sleep阻塞一下：

package demo01;

public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread() {
            @Override
            public void run() {
                synchronized (s1) {
                    s1.append("a");
                    s2.append("1");
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (s2) {
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(() -> {
            synchronized (s2) {
                s1.append("c");
                s2.append("3");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (s1) {
                    s1.append("d");
                    s2.append("4");
                    System.out.println(s1);
                    System.out.println(s2);
                }
            }
        }).start();
    }
}

当我们在嵌套的分解处加入sleep进行阻塞后，就出现了死锁问题，这段代码执行起来，就和死循环一样，不会终止，但是也不会报错，这是因为我们第一个线程执行，拿到s1这把锁，执行sleep阻塞，这时候第二个线程很大概率也被调度，拿到s2这把锁，然后执行sleep阻塞，这时候第一个线程手里有s1这把锁，醒过来后发现没有s2这把锁，没法进去下面的同步代码段，这是因为s2被第二个线程拿了，同理s2醒过来后也拿不到s1，就僵持住了，发生了死锁。
也就是发生了：
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，形成死锁。

Lock

在这里插入图片描述

package demo01;

import java.util.concurrent.locks.ReentrantLock;

//Lock锁解决线程安全问题-JDK5.0新增
class Window implements Runnable{

    private int ticket = 100;
    //定义reentrantlock对象
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try {
                //调用lock方法,锁住
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票号为:"+ticket--);
                }
                else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        new Thread(w,"Window - 1").start();
        new Thread(w,"Window - 2").start();
        new Thread(w,"Window - 3").start();
    }

}

输出结果：
在这里插入图片描述
可以看到我们使用Reentrantlock类可以实现同步的方式，但是需要我们加锁解锁，synchronized是自动执行，加锁解锁一般就如上使用try-finally执行，一般就是先定义Reentrantlock对象，然后try里面锁住，finally里面解锁。Reentrantlock构造器还可以有一个参数：boolean fair，如果为true，则实现公平锁，也就是在锁上等待时间最长的线程将获得锁的使用权。通俗的理解就是谁排队时间最长谁先执行获取锁。

package demo01;

import java.util.concurrent.locks.ReentrantLock;

//Lock锁解决线程安全问题-JDK5.0新增
class Window implements Runnable{

    private int ticket = 100;
    //定义reentrantlock对象
    private ReentrantLock lock = new ReentrantLock(true);

    @Override
    public void run() {
        while (true){
            try {
                //调用lock方法,锁住
                lock.lock();
                if(ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"售票，票号为:"+ticket--);
                }
                else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}
public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();
        new Thread(w,"Window - 1").start();
        new Thread(w,"Window - 2").start();
        new Thread(w,"Window - 3").start();
    }

}

这里我们用了公平锁，结果：
在这里插入图片描述
我们从这可以看到，如果三个线程一开始的等待时间确定了，后面一定是一样的，1进拿锁，3进，2进则3一定等的比2长，3拿锁，1执行完了后2一定比1等的长，2拿锁，后面同理，所以公平锁可以看做先进先出。

synchronized与Lock的异同

（1）synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。

（2）synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重入，但加锁和解锁需要手动进行，且次数需一样，否则其他线程无法获得锁。

（3）synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以相应中断。

ReentrantLock好像比synchronized关键字没好太多，我们再去看看synchronized所没有的，一个最主要的就是ReentrantLock还可以实现公平锁机制。什么叫公平锁呢？也就是在锁上等待时间最长的线程将获得锁的使用权。通俗的理解就是谁排队时间最长谁先执行获取锁。

一般优先顺序（实际上都一样）：
Lock->同步代码块->同步方法

练习

在这里插入图片描述

package demo01;

import java.util.concurrent.locks.ReentrantLock;

class User implements Runnable {
    private int money;
    public User() {
    }
    public User(int initMoney) {
        money = initMoney;
    }
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                lock.lock();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                money += 1000;
                System.out.println(Thread.currentThread().getName() + "存了1000元，" + "现有资金:" + money);
            } finally {
                lock.unlock();
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        User u = new User(0);
        new Thread(u, "Human - 1").start();
        new Thread(u, "Human - 2").start();
    }
}

输出结果：
在这里插入图片描述
这里注意我们用的lock方式，因为采用实现runnable接口的方式来多线程，所以我们的锁是同一个，如果我们采用继承thread类方式，我们要把lock设为static的，以保证锁的唯一。

AHawkeye
关注
专栏目录
静态同步方法（static synchronizd）
yansong_8686的专栏
12-16 3114
Java语法规定，任何线程进入同步方法、同步代码块之前，必须先获取同步方法、同步代码块对应的同步监视器。 对于同步代码块而言，程序必须为它显示的指定同步监视器（可为this也可以自定义Object类型的全局变量）；对于同步非静态方法而言，该方法的同步 监视器是this----即调用该方法的java对象；对于静态的同步方法而言，该方法的同步监视器不是this而是该类本身。
Java06
qq_56091656的博客
06-26 62
多线程 概念 程序：为完成特定任务，用某种语言编写的一组指令的集合，静态的代码 进程：正在运行的一个程序 线程：一个程序内部的一条执行路径 并行：多个CPU同时执行多个任务 并发：一个CPU同时执行多个任务 多线程的优点：提高应用程序的响应、提高CPU的利用率、改善程序结构 何时创建多线程：程序需要同时执行两个或多个任务、程序需要实现一些需要等待的任务时、需要一些后台运行的程序时 线程的创建和使用 方式一：继承于Thread类 创建一个与成语thread类的子类 重写thread类的run()
java同步代码块问题_Java之同步代码块处理实现Runnable的线程安全问题
weixin_28840811的博客
02-27 205
/*** 例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式** 1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题* 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。* 3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他* ...
Java 多线程
triggerV的博客
05-09 104
一.基本概念：程序 进程 线程 二.线程的创建和使用 1.多线程的创建 （一）方式一：继承于Thread类的子类 创建一个继承于Thread类的子类 重写Thread类的run() ---->将此线程执行的操作声明在run()中 创建Thread类的子类的对象 通过此对象调用start()：①启动当前线程 ②调用当前线程的run() 问题一：我们不能直接调用run()的方式去启动线程 问题二：再启动一个线程，不可以让已经start()的线程去执行，会报异常。我们需要重新创建一个线程的对.
【渝粤教育】21秋期末考试Java程序设计基础10232k2
渝粤题库
12-23 833
科目编号：3717 座位号 2018-2019学年度第二学期期末考试 天然气管道长输技术 试题 2018年 7 月 一、填空题（本大题共5空，每空5分，共计25分） 1．管材的选择应考虑钢材的__________________、、以及管道使用环境等方面的要求。 2．输气管道末段应该既能储气，又能。 3．在输气管道设计中考虑效率系数E是为了_____________________________________________________。 二、判断题
Java 多线程学习笔记
2301_76962889的博客
07-13 1884
*进程：**是操作系统进行资源分配和调度的基本单位，是程序的一次执行过程。**例如：**当你打开一个应用程序，如浏览器、音乐播放器等，操作系统就会为其创建一个进程。**线程：**是进程的一个执行单元，是 CPU 调度和分派的基本单位，一个进程可以包含多个线程。**例如：**在浏览器进程中，可以有多个线程同时运行，例如一个线程负责页面渲染，另一个线程负责网络请求。提高 CPU 利用率，充分利用多核处理器**例如：**下载软件使用多线程可以同时下载多个文件片段，充分利用带宽，提高下载速度。
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
黑马程序员–Java多线程讲解笔记
12-22
Java多线程是Java编程中不可或缺的部分，它允许程序同时执行多个任务，提高了程序的效率和响应速度。本文主要探讨了多线程的概念、应用场景以及Java中创建线程的两种方式。 首先，进程和线程是理解多线程的基础概念...
java多线程学习笔记
03-01
这篇文档和对应的源代码 博文链接：https://interper56-sohu-com.iteye.com/blog/172303
多线程学习笔记
03-18
多线程学习笔记 iOS开发中，多线程是一种常见的技术手段，用于优化应用程序的性能，提升用户体验。多线程的核心是让程序能够并发地执行多个任务，合理地利用设备的计算能力，尤其是在拥有多个核心的处理器上。 ...
2.表达式中的陷阱
Hyo_yew的博客
04-20 458
写在前面表达式是Java程序的基本组成单元，这里有一些很容易让人出错的陷阱，例如：》当在程序中使用算术表达式时，表达式类型的自动提升，复合赋值运算符所隐含的类型转换，会给程序带来一I些潜在陷阱》jDK1.5新增的泛型支持也有些陷阱，Java为了兼容以前不用泛型的程序，因此引入了原始类型的概念，原始类型在泛型编程中很容易致错1.JVM对字符串的处理Java程序中创建对象的常见方式有如下四种：&gt;...
多线程与同步
t008000的专栏
12-08 129
继承Thread类来创建线程类，重写run()方法作为线程执行体的坏处：   线程类继承了Thread类，无法再继承其它类； 因为每条线程都是一个Thread子类的实例，因此多个线程之间共享数据比较麻烦。 当程序调用线程对象的run()方法时，与调用普通Java对象的普通方法并无任何区别，因此绝对不会启动一条新线程。   Java语法规定，任何线程进入同步方法、同步代码块之前，必须...
多线程陷阱（不要调用run方法；静态的同步方法）
BornForIT
10-23 8664
1. 从JDK1.5开始，Java提供了3种方式来创建，启动多线程：Ø  继承Thread类来创建线程类，重写run()方法作为线程执行体。Ø  实现Runnable接口来创建线程类，重写run()方法作为线程执行体。Ø  实现Callable接口来创建线程类，重写run()方法作为线程执行体。其中第一种方式效果最差，它有2点坏处：l  线程类继承了Thread类，无法在继承其他父类。l  因为每
工厂模式的介绍及实现
户伟伟的博客
09-25 95
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
最新发布
图南的博客
09-27 141
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
智能BI平台项目
2302_79400545的博客
09-22 222
BI商业智能：数据可视化、报表可视化系统。
Android系统：系统架构
liufeismart2024的博客
09-23 481
Android的系统结构的设计混合了分层设计和分块设计。
Java多线程学习笔记：线程状态与同步机制
"这篇学习笔记主要探讨了多线程的概念、创建与启动方式、线程方法、线程的生命周期及状态、系统锁synchronized的使用和特性，包括可重入锁和锁升级机制。" 在Java编程中，多线程是一项重要的并发处理技术，它允许...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值