java多线程(四)数据同步与synchronized

最新推荐文章于 2021-05-10 16:38:11 发布
最新推荐文章于 2021-05-10 16:38:11 发布
阅读量195 收藏
点赞数
分类专栏： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39013701/article/details/100861168
版权

一.问题引出

TicketWindowRunnable.java

package com.miracle.concurrency.chapter7;


public class TicketWindowRunnable implements Runnable{

    private int index = 1;

    private final static int MAX = 50;

    @Override
    public void run() {

        while (true) {
            if (index > MAX){
                break;
            }

            try {
                Thread.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread() + " 的号码是：" + (index++));
        }
    }
}

BankVersion.java

package com.miracle.concurrency.chapter7;


public class BankVersion {

    public static void main(String[] args) {
        final TicketWindowRunnable ticketWindow = new TicketWindowRunnable();

        Thread windowThread1 = new Thread(ticketWindow, "一号窗口");
        Thread windowThread2 = new Thread(ticketWindow, "二号窗口");
        Thread windowThread3 = new Thread(ticketWindow, "三号窗口");

        windowThread1.start();
        windowThread2.start();
        windowThread3.start();
    }
}

执行BankVersion
在这里插入图片描述
发现超过50了，由此引出多线程安全问题。此问题一般发生于多个线程操作同一数据

二.synchronized关键字

1.理解

关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见（可见性），即可以代替volatile。

2.synchronized的三种应用方式

Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：

  • 1）普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁
  • 2）静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁
  • 3）同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。

3.synchronized代码示例

  • 上面线程安全问题可以通过下面代码解决
package com.miracle.concurrency.chapter7;


public class TicketWindowRunnable implements Runnable{

    private int index = 1;

    private final static int MAX = 50;

    private final Object MONITOB = new Object();

    @Override
    public void run() {

        while (true) {

            synchronized (MONITOB){
                if (index > MAX){
                    break;
                }

                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread() + " 的号码是：" + (index++));
            }
        }
    }
}

4.synchronized this锁

synchronized 加在代码块上时，需要指定锁对象，当synchronized加在方法上时，不需要(这是使用的是this锁)

SynchronizedThis.java

package com.miracle.concurrency.chapter7;


public class SynchronizedThis {

    public static void main(String[] args) {
        ThisLock thisLock = new ThisLock();
        
        /*
            这里开启两个线程，分别执行ThisLock.m1，   
            ThisLock.m2 方法
            由于 synchronized 加在方法上时，默认使用this对象当锁
            导致两个线程用一个锁(虽然执行的不是同一个方法)
            执行结果为两个线程顺序执行
         */
        new Thread("T1"){
            @Override
            public void run() {
                thisLock.m1();
            }
        }.start();

        new Thread("T2"){
            @Override
            public void run() {
                thisLock.m2();
            }
        }.start();
    }

}

class ThisLock{

    public synchronized void m1(){
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void m2(){
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

接下来改写成代码块锁的形式
SynchronizedThis.java

package com.miracle.concurrency.chapter7;


public class SynchronizedThis {

    public static void main(String[] args) {
        ThisLock thisLock = new ThisLock();
        
        new Thread("T1"){
            @Override
            public void run() {
                thisLock.m1();
            }
        }.start();

        new Thread("T2"){
            @Override
            public void run() {
                thisLock.m2();
            }
        }.start();
    }

}

class ThisLock{

    private final Object LOCK = new Object();

    public synchronized void m1(){
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void m2(){
        synchronized(LOCK){
            try {
                System.out.println(Thread.currentThread().getName());
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

5.synchronized class锁

当synchronized加到静态方法上时，用的是class锁

SynchronizedStatic.java

package com.miracle.concurrency.chapter7;


public class SynchronizedStatic {

    static {
        synchronized (SynchronizedStatic.class) {
            System.out.println("static " + Thread.currentThread().getName());
            try {
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized static void m1(){
        System.out.println("m1 " + Thread.currentThread().getName());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized static void m2(){
        System.out.println("m2 " + Thread.currentThread().getName());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void m3(){
        System.out.println("m3 " + Thread.currentThread().getName());
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试类
SynchronizedStaticTest.java

package com.miracle.concurrency.chapter7;


public class SynchronizedStaticTest {

    public static void main(String[] args) {
        new Thread("T1"){
            @Override
            public void run() {
                SynchronizedStatic.m1();
            }
        }.start();
        new Thread("T2"){
            @Override
            public void run() {
                SynchronizedStatic.m2();
            }
        }.start();
        new Thread("T3"){
            @Override
            public void run() {
                SynchronizedStatic.m3();
            }
        }.start();
    }
}

三.死锁问题

1.死锁示例

DeadLock.java

package com.miracle.concurrency.chapter8;


public class DeadLock {

    private OtherService otherService;

    public DeadLock(OtherService otherService) {
        this.otherService = otherService;
    }

    private final Object LOCK = new Object();

    public void m1(){
        synchronized (LOCK){
            System.out.println("m1");
            otherService.s1();
        }
    }

    public void m2(){
        synchronized (LOCK){
            System.out.println("m2");
        }
    }
}

OtherService.java

package com.miracle.concurrency.chapter8;


public class OtherService {

    private final Object LOCK = new Object();

    private DeadLock deadLock;

    public void s1() {
        synchronized (LOCK) {
            System.out.println("s1=============");
        }
    }

    public void s2(){
        synchronized (LOCK) {
            System.out.println("s2=============");
            deadLock.m2();
        }
    }

    public void setDeadLock(DeadLock deadLock) {
        this.deadLock = deadLock;
    }
}

测试程序
DeadLockTest.java

package com.miracle.concurrency.chapter8;


public class DeadLockTest {
    public static void main(String[] args) {
        OtherService otherService = new OtherService();
        DeadLock deadLock = new DeadLock(otherService);
        otherService.setDeadLock(deadLock);

        new Thread(){
            @Override
            public void run() {
                while (true){
                    deadLock.m1();
                }
            }
        }.start();

        new Thread(){
            @Override
            public void run() {
                while (true) {
                    otherService.s2();
                }
            }
        }.start();
    }
}

2.查看程序中的死锁

在终端命令行上执行：jps找到程序的java进程号
在这里插入图片描述
执行：jstack + 刚才的进程号
在这里插入图片描述
在这里插入图片描述
根据这里发现两个线程产生死锁

qq_39013701
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Synchronized同步方法
u014785687的博客
03-07 3508
“非线程安全”其实会在多个线程对同一个对象中的实例变量进行并发访问时发生，产生的后果就是“脏读”，也就是取到的数据其实是被更改过的。1**、方法内的变量为线程安全的** 方法内部的私有变量，则不存在“非线程安全”的问题，所得结果也就是“线程安全”的。2、实例变量非线程安全
多线程学习 synchronized加锁 保持数据一致 四
taiguolaotu的博客
07-29 469
synchronized 修饰代码块 对象锁标记 上代码 package com.baigu.demo1.stack; public class TestStack { public static void main(String[] args) throws InterruptedException { Stack stack = new Stack(); // stack.print(); // stack.posh('C'); //
关于synchronized在操作数据库时候用的地方
gbh666666的博客
03-15 998
synchronized 这个关键字，如果是多个操作一起操作数据库，尤其是涉及到增删改的时候，一组操作一定要加这个关键字，否则在会出现幻读或者虚度。
Android中synchronized加锁控制主线程和子线程（同步执行、顺序执行）
aidou1314的博客
05-10 1352
参考网址：https://blog.csdn.net/night_dragon/article/details/54409473 https://blog.csdn.net/huanyuminhao/article/details/51960256 1.顺序执行（先让子线程执行完毕，再继续执行主线程） private Object obj = new Object(); private void test(){ new Thread(){ @Override
Java多线程编程二(synchronized同步方法和synchronized同步代码块）
qq_33225399的博客
02-20 1284
对象及变量的并发访问一、synchronized同步方法 本文主要讲述如何解决非线程安全问题 一、synchronized同步方法 方法内的变量为线程安全 “非线程安全“问题存在与实例变量中，如果是方法内部的私有变量，则不存在“非线程安全“问题，也就是线程安全的。 public class MyThread extends Thread { @Override public v...
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
Java多线程共享数据、同步、通信
12-22
　b)使用runnable可以解决性和不能共享的问题（不是说使用runnable解决了共享问题，只是相对于创建Thread来说，它可以算的上是共享了，为了获得更精确的共享问题，它必须的使用线程同步操作）。实现了runnable接口...
java多线程编程之使用Synchronized块同步方法
09-04
synchronized块来同步一个对象变量,也可以使用synchronized块来同步类中的静态方法和非静态方法,下面使用Synchronized块同步方法
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
Java中synchronized同步锁用法及作用范围
热门推荐
在梅边的专栏
01-18 7万+
Java 中的 synchronized 关键字可以在多线程环境下用来作为线程安全的同步锁。本文主要对 synchronized 的作用，以及其有效范围进行讨论。 Java中的对象锁和类锁：java的对象锁和类锁在锁的概念上基本上和内置锁是一致的，但是，两个锁实际是有很大的区别的，对象锁是用于对象实例方法，或者一个对象实例上的，类锁是用于类的静态方法或者一个类的class对象上的。我们知道，类的
java-study Thread线程、synchronized同步锁、await()/notify()
luck_lin
06-16 515
package com.TestThread; public class Test { public static void main(String[] args) { Account a0 = new Account(); Account a1 = new Account(); User u0 = new User(a0, 2000); User u1 = new User(a1, 2000); Thread t.
线程的安全与数据同步之synchronized
weixin_43032413的博客
12-01 138
前序 无论是互联网系统还是企业系统,在追求稳定计算的同时也在追求系统更高的吞吐量,这也对我们开发人员提出了更高的要求,如何开发高效率的程序是每个程序员必须掌握的技能,并发或者并行的的程序并不意味着满足越多的Thread,线程的多少对系统的性能来说是一个抛物线,同时多线程的引入也带来了共享数据的安全隐患! 数据同步 接下来我们用代码说明数据不一致的问题: public class WinRunnab...
java多线程（四）：Runnable和Thread的简单使用
weixin_42046829的博客
09-09 273
public class MyRunnable implements Runnable{ private String name; public MyRunnable(String name) { this.name = name; } @Override public void run() { for (int i = 1; i < 11; i++){ System.out.println(nam.
线程安全、数据同步之 synchronized 与 Lock
u010112268的博客
04-02 192
转载https://www.cnblogs.com/jycboy/p/5620691.html 写在前面 本篇文章讲的东西都是Android开源网络框架NoHttp的核心点，当然线程、多线程、数据安全这是Java中就有的，为了运行快我们用一个Java项目来讲解。 为什么要保证线程安全/数据同步 当多个子线程访问同一块数据的时候，由于非同步访问，所以数据可能被同时修改，所以这时候...
synchronized 同步
sifanchao的博客
11-14 985
同步问题的引出 需求：多个线程同时卖票 class MyThread implements Runnable { private int ticket = 10; @Override public void run() { while (this.ticket &amp;amp;amp;gt; 0) { try { ...
通过synchronized简单实现线程同步保证数据安全性（两例）
small__snail__5的博客
08-01 548
//【注意】：何时需要线程同步：1.有共享数据；2.对共享数据有写的操作；3.多线程环境 //例一：模拟银行取款，对同一账户两个人一个通过ATM一个通过人工同时取款，此时相当于两个线程，那么此时对同一共享数据余额有写的操作，且是多线程则需要使用线程同步，见代码： package ThreadTest; class Picket{ private double num; public v...
后端开发是一个涉及广泛技术和工具的领域.docx
最新发布
04-30
后端开发是一个涉及广泛技术和工具的领域，这些资源对于构建健壮、可扩展和高效的Web应用程序至关重要。以下是对后端开发资源的简要介绍： 首先，掌握一门或多门编程语言是后端开发的基础。Java、Python和Node.js是其中最受欢迎的几种。Java以其跨平台性和丰富的库而著名，Python则因其简洁的语法和广泛的应用领域而备受欢迎。Node.js则通过其基于JavaScript的单线程异步I/O模型，为Web开发提供了高性能的解决方案。 其次，数据库技术是后端开发中不可或缺的一部分。关系型数据库（如MySQL、PostgreSQL）和非关系型数据库（如MongoDB、Redis）各有其特点和应用场景。关系型数据库适合存储结构化数据，而非关系型数据库则更适合处理大量非结构化数据。 此外，Web开发框架也是后端开发的重要资源。例如，Express是一个基于Node.js的Web应用开发框架，它提供了丰富的API和中间件支持，使得开发人员能够快速地构建Web应用程序。Django则是一个用Python编写的Web应用框架，它采用了MVC的软件设计模式，使得代码结构更加清晰和易于维护。
华为数字化转型实践28个精华问答glkm.pptx
04-30
华为数字化转型实践28个精华问答glkm.pptx
java多线程数据同步
04-19
以下是几种常见的Java多线程数据同步的方式： 1. synchronized关键字：使用synchronized关键字可以修饰方法或代码块，确保同一时间只有一个线程可以执行被修饰的代码。当一个线程进入synchronized代码块时，会自动...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值