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

时间： 2024-10-29 19:06:11

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

彻底理解线程同步与同步代码块synchronized

1 public class Demo { 2 public static synchronized void fun1(){ 3 } 4 public synchronized void fun2(){ 5 } 6 public static void main(String args[]) throws Exception{ 7 synchronized(xxx) { 8 9 } 10 } 11 } 三种同步类型 虽然写法不同,但实际上,只有一种,就是[同步代码块].这是核心核心核心.同步方

java同步代码块

/** abc三个售票窗口,售50张票. 需求:可以做到同时销售,且不能卖重叠的,以及不能超过50 同步代码块 synchronized(对象){     同步代码块: } 对象如同锁,持有锁的线程可以在同步中执行 没有持有锁的线程即使获得CPU的执行器,也无法执行. 同步前提: 1.多线程的代码块才需要同步,即run里的代码才需要加同步.对共享数据加同步 2.必须是多个线程使用同一个锁,才需要同步 好处:提高多线程的安全问题 弊端:多个线程需要判断锁,较为消耗资源 */ class Tickt

JAVA线程安全之synchronized关键字的正确用法

JAVA线程安全关于synchronized关键字的用法,今天才知道原来我一直错了.以为用了synchronized关键字包住了代码就可以线程同步安全了. 测试了下.发现是完全的错了.synchronized必须正确的使用才是真正的线程安全...虽然知道这种写法,一直以为却由于懒而用了错误的方法. 看来基础还没有打好.仍需复习加强!工作中犯这种错误是不可原谅的,要知道使用synchronized关键字的地方都是数据敏感的!汗一把... 先贴代码: [java] view plaincopypri

Java并发编程1——线程状态、synchronized

以下内容主要总结自<Java多线程编程核心技术>,不定时补充更新. 一.线程的状态 Java中,线程的状态有以下6类:NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED.各状态之间的关系可用下图表示: 二.常用方法介绍 1.thread.start()和thread.run()的区别 1 public static void main(String[] args) { 2 Thread t = new Thread(); 3 t

【java并发】传统线程互斥技术—synchronized

在多个线程同时操作相同资源的时候,就会遇到并发的问题,如银行转账啊.售票系统啊等.为了避免这些问题的出现,我们可以使用synchronized关键字来解决,下面针对synchronized常见的用法做一个总结.首先写一个存在并发问题的程序,如下: public class TraditionalThreadSynchronized { public static void main(String[] args) { //在静态方法中不能new内部类的实例对象 //private Outputer

java中多线程模拟（多生产，多消费，Lock实现同步锁，替代synchronized同步代码块）

import java.util.concurrent.locks.*; class DuckMsg{ int size;//烤鸭的大小 String id;//烤鸭的厂家和标号 DuckMsg(){ } DuckMsg(int size, String id){ this.size=size; this.id=id; } public String toString(){ return id + " 大小为:" + size; } } class Duck{ private int

java：synchronized 同步代码块

synchronized:利用上锁实现数据同步,避免多线程操作的情况下,数据出现异常. 当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行. 另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 在代码块前加上 synchronized关键字,则此代码块就成为同步代码块, 格式: synchronized(同步对象){ 需要同步的代码: } class MyThread implements Runnab

Java线程安全与同步代码块

因为在电商网站工作的原因,对于秒杀.闪购等促销形式相当熟悉.无外乎商家拿出一定量的库存去做所谓的"亏本买卖",其目的是用有限的库存去吸引无限的流量.然而,我却碰到过因为系统问题,导致秒杀品超卖的情况.可怜的商户其实只提供了10双9.9元的童鞋做秒杀,却在瞬间内卖出了1000双! 类似这样的问题,在非线程安全的程序设计中十分常见,我们下面运行一个秒杀的程序: public class SalesThread implements Runnable { private int stock

Java---13---多线程：解决多线程的安全问题---synchronized 同步代码块

还是之前卖票的例子: class Test implements Runnable { private int num = 50; Object obj = new Object(); public void run () { while (true) { if (num >= 0) { try { Thread.sleep(20); } catch (Exception e) { // TODO: handle exception System.out.println(e.toString()