AI 助理
备案控制台
开发者社区 安全 文章 正文

JAVA之旅（十三）——线程的安全性，synchronized关键字，多线程同步代码块，同步函数，同步函数的锁是this

2016-06-04 1019
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： JAVA之旅（十三）——线程的安全性，synchronized关键字，多线程同步代码块，同步函数，同步函数的锁是this 我们继续上个篇幅接着讲线程的知识点一.线程的安全性 当我们开启四个窗口（线程）把票陆陆续续的卖完了之后，我们要反思一下，这里面有没有...

JAVA之旅（十三）——线程的安全性，synchronized关键字，多线程同步代码块，同步函数，同步函数的锁是this

我们继续上个篇幅接着讲线程的知识点

一.线程的安全性

当我们开启四个窗口（线程）把票陆陆续续的卖完了之后，我们要反思一下，这里面有没有安全隐患呢？在实际情况中，这种事情我们是必须要去考虑安全问题的，那我们模拟一下错误

package com.lgl.hellojava;

import javax.security.auth.callback.TextInputCallback;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {

        /**
         * 需求：简单的卖票程序，多个线程同时卖票
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        Thread t4 = new Thread(myThread);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

/**
 * 卖票程序
 * 
 * @author LGL
 *
 */
class MyThread implements Runnable {

    // 票数
    private  int tick = 100;

    @Override
    public void run() {
        while (true) {
            if (tick > 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println("卖票:" + tick--);
            }
        }
    }
}

我们输出的结果

这里写图片描述

这里出现了0票，如果你继续跟踪的话，你会发现，还会出现-1，-2之类的票，这就是安全隐患，那原因是什么呢？

  • 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一个部分，还没有执行完，另外一个线程参与了执行，导致共享数据的错误

解决办法：对多条操作共享数据的语句，只能让一个线程都执行完再执行过程中其他线程不可以参与运行

JAVA对多线程的安全问题提供了专业的解决办法，就是同步代码块


    synchronized(对象){
        //需要同步的代码
    }

那我们怎么用呢？

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {

        /**
         * 需求：简单的卖票程序，多个线程同时卖票
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        Thread t4 = new Thread(myThread);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

/**
 * 卖票程序
 * 
 * @author LGL
 *
 */
class MyThread implements Runnable {

    // 票数
    private  int tick = 100;

    Object oj = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized(oj){
                if (tick > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("卖票:" + tick--);
                }
            }

        }
    }
}

这样，就输出

这里写图片描述

二.多线程同步代码块

我们为什么可以这样去同步线程？

对象如同锁，持有锁的线程可以在同步中执行，没有执行锁的线程即使获取了CPU的执行权，也进不去，因为没有获取锁，我们可以这样理解

  • 四个线程，哪一个进去就开始执行，其他的拿不到执行权，所以即使拿到了执行权，也进不去，这个同步能解决线程的安全问题

但是，同步是有前提的

  • 1.必须要有两个或者两个以上的线程，不然你同步也没必要呀
  • 2.必须是多个线程使用同一锁

必须保证同步中只能有一个线程在运行

但是他也有一个弊端：那就是多个线程都需要判断锁，较为消耗资源

三.多线成同步函数

我们可以写一段小程序，来验证这个线程同步的问题，也就是说我们看看下面这段程序是否有安全问题，有的话，如何解决？

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {

        /**
         * 需求：银行里有一个金库 有两个人要存钱300
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);

        t1.start();
        t2.start();

    }

}

/**
 * 存钱程序，一次100
 * @author LGL
 *
 */
class MyThread implements Runnable {

    private Bank b = new Bank();

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            b.add(100);
        }
    }

}

/**
 * 银行
 * @author LGL
 *
 */
class Bank {
    private int sum;

    public void add(int n) {
        sum = sum + n;
        System.out.println("sum:" + sum);
    }
}

当你执行的时候你会发现

这里写图片描述

这里是没错的，存了600块钱，但是，这个程序是有安全隐患的

如何找到问题？

  • 1.明确哪些代码是多线成运行代码
  • 2.明确共享数据
  • 3.明确多线成运行代码中哪些语句是操作共享数据的

那我们怎么找到安全隐患呢？我们去银行的类里面做些认为操作

/**
 * 银行
 * @author LGL
 *
 */
class Bank {
    private int sum;

    public void add(int n) {
        sum = sum + n;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("sum:" + sum);
    }
}

让他sleep一下你就会发现

这里写图片描述

这样的话，我们就可以使用我们的同步代码了

/**
 * 银行
 * 
 * @author LGL
 *
 */
class Bank {
    private int sum;

    Object j = new Object();

    public void add(int n) {
        synchronized (j) {
            sum = sum + n;
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("sum:" + sum);
        }
    }
}

这样代码就可以同步了

这里写图片描述

哪些代码该同步，哪些不该同步，你一定要搞清楚，根据上面的3个条件

大家有没有注意到，函数式具有封装代码的特定，而我们所操作的同步代码块也是有封装代码的特性，拿这样的话我们就可以换一种形式去操作，那就是写成函数的修饰符


/**
 * 银行
 * 
 * @author LGL
 *
 */
class Bank {
    private int sum;

    public synchronized void add(int n) {
        sum = sum + n;
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("sum:" + sum);
    }
}

这样也是OK的

四.同步函数的锁是this

既然我们学习了另一种同步函数的写法，那我们就可以把刚才的买票小例子进一步封装一下了

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {

        /**
         * 需求：简单的卖票程序，多个线程同时卖票
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        Thread t4 = new Thread(myThread);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

/**
 * 卖票程序
 * 
 * @author LGL
 *
 */
class MyThread implements Runnable {

    // 票数
    private int tick = 100;

    @Override
    public synchronized void run() {
        while (true) {
            if (tick > 0) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread()+"卖票:" + tick--);
            }
        }
    }
}

但是这样做，你却会发现一个很严重的问题，那就是

这里写图片描述

永远只有0线程在执行卖票

那是因为我们并没有搞清楚需要同步哪一个代码段，我们应该执行的只是里面的那两段代码，而不是整个死循环，所以我们得封装个函数进行线程同步

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {

        /**
         * 需求：简单的卖票程序，多个线程同时卖票
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        Thread t3 = new Thread(myThread);
        Thread t4 = new Thread(myThread);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }

}

/**
 * 卖票程序
 * 
 * @author LGL
 *
 */
class MyThread implements Runnable {

    // 票数
    private int tick = 100;

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

    private synchronized void show() {
        if (tick > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread() + "卖票:" + tick--);
        }
    }
}

这样输出解决了

这里写图片描述

问题是被解决了，但是随之问题也就来了

  • 同步函数用的是哪一个锁呢？

函数需要被对象调用，那么函数都有一个所属对象的引用，就是this，所以同步函数所引用的锁是this,我们来验证一下，我们把程序改动一下

使用两个线程来卖票，一个线程在同步代码块中，一个线程在同步函数中，都在执行卖票动作

package com.lgl.hellojava;

//公共的   类   类名
public class HelloJJAVA {

    public static void main(String[] args) {

        /**
         * 需求：简单的卖票程序，多个线程同时卖票
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread);
        Thread t2 = new Thread(myThread);
        // Thread t3 = new Thread(myThread);
        // Thread t4 = new Thread(myThread);

        t1.start();
        myThread.flag = false;
        t2.start();
        // t3.start();
        // t4.start();
    }

}

/**
 * 卖票程序
 * 
 * @author LGL
 *
 */
class MyThread implements Runnable {

    // 票数
    private int tick = 100;

    Object j = new Object();

    boolean flag = true;

    @Override
    public void run() {

        if (flag) {
            while (true) {
                synchronized (j) {
                    if (tick > 0) {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread() + "code:"
                                + tick--);
                    }
                }
            }
        } else {
            while (true) {
                show();
            }
        }

    }

    private synchronized void show() {
        if (tick > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread() + "show:" + tick--);
        }
    }
}

当我们运行的时候就发现

这里写图片描述

他只在show中进行，那是为什么呢？因为主线程开启的时候瞬间执行，我们要修改一下，让线程1开启的时候，主线程睡个10毫秒试试

    t1.start();

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        myThread.flag = false;
        t2.start();

这样输出的结果貌似是交替进行

这里写图片描述

但是所知而来的，是0票，这说明这个线程不安全，我们明明加了同步啊，怎么还是不安全呢？因为他用的不是同一个锁，一个用Object，一个是用this的锁，我们再改动一下，我们把Object更好为this，这样输出

这里写图片描述

现在就安全，也正确了

好的，我们本篇幅就先到这里了，我们下篇也继续讲线程

如果有兴趣，可以加入群：555974449

文章标签：
Java
安全
小程序
关键词：
Java Synchronized
Java多线程
Java线程synchronized
线程synchronized
Java线程
刘桂林
目录
相关文章
东方睿赢
|
1天前
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
12 4
丰宝宝
|
1天前
|
消息中间件 供应链 Java
掌握Java多线程编程的艺术
【10月更文挑战第29天】 在当今软件开发领域，多线程编程已成为提升应用性能和响应速度的关键手段之一。本文旨在深入探讨Java多线程编程的核心技术、常见问题以及最佳实践，通过实际案例分析，帮助读者理解并掌握如何在Java应用中高效地使用多线程。不同于常规的技术总结，本文将结合作者多年的实践经验，以故事化的方式讲述多线程编程的魅力与挑战，旨在为读者提供一种全新的学习视角。
丰宝宝
19 3
shuj
|
2天前
|
安全 Java 调度
Java中的多线程编程入门
【10月更文挑战第29天】在Java的世界中，多线程就像是一场精心编排的交响乐。每个线程都是乐团中的一个乐手，他们各自演奏着自己的部分，却又和谐地共同完成整场演出。本文将带你走进Java多线程的世界，让你从零基础到能够编写基本的多线程程序。
shuj
12 1
东方睿赢
|
3月前
|
存储 监控 Java
Java多线程优化：提高线程池性能的技巧与实践
Java多线程优化：提高线程池性能的技巧与实践
东方睿赢
103 1
碳基肥宅
|
6月前
|
设计模式 监控 Java
Java多线程基础-11：工厂模式及代码案例之线程池（一）
本文介绍了Java并发框架中的线程池工具，特别是`java.util.concurrent`包中的`Executors`和`ThreadPoolExecutor`类。线程池通过预先创建并管理一组线程，可以提高多线程任务的效率和响应速度，减少线程创建和销毁的开销。
碳基肥宅
180 2
Hacynn
|
6月前
|
Java 数据库
【Java多线程】对线程池的理解并模拟实现线程池
【Java多线程】对线程池的理解并模拟实现线程池
Hacynn
57 1
yinying293
|
3月前
|
安全 算法 Java
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（下）
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
yinying293
74 6
yinying293
|
3月前
|
存储 安全 Java
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（中）
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
yinying293
83 5
yinying293
|
3月前
|
存储 安全 Java
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）（上）
17 Java多线程（线程创建+线程状态+线程安全+死锁+线程池+Lock接口+线程安全集合）
yinying293
79 3
杰哥在此
|
4月前
|
设计模式 存储 安全
Java面试题：设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池，并解释其背后的原理。结合观察者模式与Java并发框架，设计一个可扩展的事件处理系统
Java面试题：设计一个线程安全的单例类并解释其内存占用情况?使用Java多线程工具类实现一个高效的线程池，并解释其背后的原理。结合观察者模式与Java并发框架，设计一个可扩展的事件处理系统
杰哥在此
61 1

热门文章

最新文章

  • 1
    深入java虚拟机学习 -- 类的加载机制(三)
  • 2
    Rhino 是一个完全使用Java语言编写的开源JavaScript实现。Rhino通常用于在Java程序中，为最终用户提供脚本化能力。它被作为J2SE 6上的默认Java脚本化引擎。
  • 3
    基于Java和MySQL实现的大学生学籍管理系统(毕业设计附完整项目代码)
  • 4
    Java类库中的一些常用的查找排序
  • 5
    通过java api提交自定义hadoop 作业
  • 6
    再转一篇关于Memcached在JAVA项目里应用的入门文章
  • 7
    JAVA DES
  • 8
    16.2. jps - Java Virtual Machine Process Status Tool
  • 9
    Java本地文件操作(六）文件的简单读写
  • 10
    JAVA SERVLET 属性范围样例
  • 1
    Android进程与线程
    49
  • 2
    Java并发编程：实现高效、线程安全的多线程应用
    58
  • 3
    python并发编程: Python使用线程池在Web服务中实现加速
    63
  • 4
    LInux下Posix的传统线程示例
    49
  • 5
    Springboot启动的时候初始化的线程池默认配置tomcat
    157
  • 6
    SpringBoot实现多线程定时任务动态定时任务配置文件配置定时任务
    604
  • 7
    Python开启线程和线程池的方法
    59
  • 8
    【C/C++ 线程池设计思路】 深入探索线程池设计：任务历史记录的高效管理策略
    170
  • 9
    【Qt 底层之事件驱动系统】深入理解 Qt 事件机制：主事件循环与工作线程的交互探究，包括 QML 的视角
    1310
  • 10
    【C++ 线程包裹类设计】跨平台C++线程包装类：属性设置与平台差异的全面探讨
    109

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • 如何通过 Serverless 提高 Java 微服务治理效
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • 多IO线程优化版

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月