线程同步；同步方法、同步块（synchronized）

于 2021-04-04 10:31:50 发布
阅读量239 收藏 1
点赞数
分类专栏： java学习之多线程 文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hgg657046415/article/details/115368606
版权

线程同步

原理：

线程同步就是一个让多线程排队的机制。当多线程访问一个对象，并且还有某些线程想修改这个对象时，这时候就需要线程同步。让多个需要访问此对象的线程进入对象等待次池，形成队列，等待前面线程使用完毕，下一个线程再使用

三大不安全案例：

（1）买票：
package com.heima.syn;

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"宏哥").start();
        new Thread(buyTicket,"黄牛").start();
        new Thread(buyTicket,"美女").start();

    }
}

class BuyTicket implements Runnable{

    //票数
    private int ticket = 10;
    //外部停止方式
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void buy() throws InterruptedException {
        if (ticket<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ ticket-- +"张票");
    }
}

在这里插入图片描述
造成有人拿到0，-1的情况就是，在剩下最后一张票时，三个线程的人同时看到了这张票，所以三个人都拿了。

（2）银行取钱：
package com.heima.syn;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(200000,"泡妞基金");

        Drawing Me = new Drawing("我",account,100000);
        Drawing girlFriend = new Drawing("女朋友",account,150000);

        Me.start();
        girlFriend.start();
    }
}

class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:
class Drawing extends Thread{

    Account account;//定义账户
    int drawingMoney;//要取多少钱
    int nowMoney;//你取到手里的钱

    public Drawing(String name, Account account, int drawingMoney) {
        super(name);//父类Thread的name
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱操作
    @Override
    public void run() {
        //判断钱够不够取
        if (account.money - drawingMoney < 0){
            System.out.println("取钱失败,余额不足");
            return;
        }
        try {
            Thread.sleep(100);//放大问题的发生性
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额 = 余额 - 要取的钱
       account.money =account.money - drawingMoney;
       //手里的钱
        nowMoney = nowMoney + drawingMoney;

        System.out.println(account.name+"余额为:"+account.money);
        System.out.println(this.getName()+"手里的钱:"+nowMoney);
    }
}

在这里插入图片描述

（3）线程不安全的集合
package com.heima.syn;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 1000; i++) {//开启1000条线程,list的每个位置理论上存贮每一个不同的线程的name
            new Thread(()->{
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }
}

在这里插入图片描述

这里理论上是要有1000，但是因为同时有不同的线程 给的 list 的同一个位置赋值，导致的覆盖，size变小

实现线程同步：synchronized

因为存在以上问题，所以为了数据在方法中被访问的正确性，在访问时加入锁机制 synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待。（synchronized出了其作用范围就会解锁）

同步方法：

在这里插入图片描述

（1）买票：
package com.heima.syn;

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();

        new Thread(buyTicket,"宏哥").start();
        new Thread(buyTicket,"黄牛").start();
        new Thread(buyTicket,"美女").start();

    }
}

class BuyTicket implements Runnable{

    //票数
    private int ticket = 10;
    //外部停止方式
    boolean flag = true;
    @Override
    public void run() {
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //synchronized 同步方法 锁的是this
    private synchronized void buy() throws InterruptedException {
        if (ticket<=0){
            flag = false;
            return;
        }
        Thread.sleep(100);
        System.out.println(Thread.currentThread().getName()+"拿到了第"+ ticket-- +"张票");
    }
}

在这里插入图片描述

（2）要点：

（1）同步方法默认锁的是this
（2）不需要释放锁，出了作用范围自动释放
（3）如果给一个大的方法加锁，会影响效率，浪费资源，只有方法里面需要修改的内容才需要加锁（所以有了方法块）

同步块：

在这里插入图片描述

（1）银行取钱：
package com.heima.syn;

public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(200000,"泡妞基金");

        Drawing Me = new Drawing("我",account,100000);
        Drawing girlFriend = new Drawing("女朋友",account,150000);

        Me.start();
        girlFriend.start();
    }
}

class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行:
class Drawing extends Thread{

    Account account;//定义账户
    int drawingMoney;//要取多少钱
    int nowMoney;//你取到手里的钱

    public Drawing(String name, Account account, int drawingMoney) {
        super(name);//父类Thread的name
        this.account = account;
        this.drawingMoney = drawingMoney;
    }

    //取钱操作
    //把synchronized放在run，因为默认锁的是this，所以这种情况下会锁住Drawing，但是我们的目的是要锁住account
    //所以我们这里要放的位置是正确的，但是要锁的对象不正确
    @Override
    public void run() {

        //锁的对象是变化的量
        synchronized (account){
            //判断钱够不够取
            if (account.money - drawingMoney < 0){
                System.out.println("取钱失败,余额不足");
                return;
            }
            try {
                Thread.sleep(100);//放大问题的发生性
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //卡内余额 = 余额 - 要取的钱
            account.money =account.money - drawingMoney;
            //手里的钱
            nowMoney = nowMoney + drawingMoney;

            System.out.println(account.name+"余额为:"+account.money);
            System.out.println(this.getName()+"手里的钱:"+nowMoney);
        }
    }
}

在这里插入图片描述

（2）线程不安全的集合安全化：
package com.heima.syn;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        for (int i = 0; i < 1000; i++) {//开启1000条线程,线程里的run是给list的每个位置理论上存贮每一个不同的线程的name
            new Thread(()->{ {
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(list.size());
    }
}

在这里插入图片描述

冬天别舔栏杆哦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java多线程编程之使用Synchronized块同步方法
09-04
synchronized块来同步一个对象变量,也可以使用synchronized块来同步类中的静态方法和非静态方法,下面使用Synchronized块同步方法
线程的同步-同步块
brimen的博客
03-06 187
线程的同步，除了同步方法外，我们还可以使用代码块，使用代码块比同步方法有更好的效果。。 追其同步的根本目的，是控制竞争资源的正确访问，因此只要在访问竞争资源的时候，只要保证同一时刻只能有一个线程访问即可，因此Java引入了同步代码块的策略，以提高其性能。我们对上一篇文章进行改进： User类： package thread_synchronization; public class User {...
java多线程-同步块
weixin_30689307的博客
08-30 88
Java 同步块（synchronized block）用来标记方法或者代码块是同步的。Java 同步块用来避免竞争。本文介绍以下内容： Java 同步关键字（synchronzied） 实例方法同步 静态方法同步 实例方法中同步块 静态方法中同步块 Java 同步示例 Java 同步关键字（synchronized） Java 中的同步块用 synchronized 标记...
Java 多线程同步-同步代码块&&同步方法
刘伟佳的博客
03-04 1199
我们回忆一下之前的火车票案例： package com.veeja.thread; /** * @Author veeja * 2021/3/2 11:35 */ public class BuyTicketThreadExtendTest { public static void main(String[] args) { BuyTicketThreadExtend t1 = new BuyTicketThreadExtend("one"); BuyTick
多线程（线程不安全、线程同步方法和同步代码块）
qq_42585774的博客
10-04 588
一、线程不安全问题 当多个线程共享同一个资源时，一个线程未完成全部操作的时候，其他线程修改了数据，造成数据不安全问题 public void run(){ while(true){ num++; count--; try{ Thread.sleep(500); //模拟网络延时 }catch(InterruptedException){//......} System.out...
线程安全问题之线程同步机制（同步代码块）
一点一滴
08-06 1567
继续讨论多窗口卖票问题中的线程安全问题： 方式二： 一、问题： 出现了线程安全问题 ? 二、问题的原因： 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。 三、出现线程安全问题的根本原因： 1、存在两个或者两个以上的线程对象，而且线程之间共享着一个资源。 2、有多个语句操作了共享资源。
Java多线程synchronized同步方法详解
08-24
主要介绍了Java多线程synchronized同步方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java多线程编程之使用Synchronized关键字同步类方法
09-04
JAVA中要想解决“脏数据”的问题，最简单的方法就是使用synchronized关键字来使run方法同步,看下面的代码，只要在void和public之间加上synchronized关键字
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
java多线程编程之使用Synchronized块同步变量
09-04
我们可以通过synchronized块来同步特定的静态或非静态方法。要想实现这种需求必须为这些特性的方法定义一个类变量，然后将这些方法的代码用synchronized块括起来，并将这个类变量作为参数传入synchronized块
JAVA多线程——线程同步机制，同步方法和同步块
万里顾一程的博客
09-02 2121
JAVA多线程——线程同步机制，同步方法和同步块 并发：同一个对象被多个线程同时操作 线程同步：处理多线程问题时，多个线程访问同一个对象，并且某个对象还想修改这个线程。这时候就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。 锁机制：由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来的访问冲突问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制（synchronized）,当一个线程获得对象
【多线程】synchronized同步代码块
热门推荐
柠檬树
01-23 3万+
一、前言        使用synchronized声明的方法在 某些情况下是有弊端的，比如A线程调用同步的方法执行一个长时间的任务，那么B线程就必须等待比较长的时间才能执行，这种情况可以使用synchronized代码块去优化代码执行时间，也就是通常所说的减少锁的粒度。 /** * 使用synchronized代码块减小锁的粒度，提高性能 * @author alienware *
JAVA多线程——实现同步
weixin_38719347的博客
07-26 1万+
转载(https://www.cnblogs.com/soundcode/p/6295910.html)加上了自己的补充和理解 为何要使用同步？ java允许多线程并发控制，当多个线程同时操作一个可共享的资源变量时（如数据的增删改查）， 将会导致数据不准确，相互之间产生冲突，因此加入同步锁以避免在该线程没有完成操作之前，被其他线程的调用， 从而保证了该变量的唯一性和准确性。 线程同步的方...
JAVA线程同步方法和同步代码块
u012133048的博客
08-08 3156
JAVA 线程同步方法和同步代码块 线程安全和非线程安全 脏读 非线程安全：多个线程对同一个对象的中的实例变量进行并发访问，产生后果就是脏读，也就是获取的数据被更改。 非线程安全问题存在与“实例变量”中，如果是方法内部的私有变量，就不存在“非线程安全问题”。 线程安全：获得实例变量的值是经过同步处理的，不会出现脏读现象。 结论：只有共享资源才需要被同步，如果不是共享资源，则没有必要同步...
java多线程:线程的同步-同步块
carl_jiang的专栏
08-29 337
除了同步，同步方法外，还可以使用同步dai'm 转载自 http://lavasoft.blog.51cto.com/62575/221922
Java线程：线程的同步-同步块
呆萌的专栏
08-07 343
Java线程：线程的同步-同步块   对于同步，除了同步方法外，还可以使用同步代码块，有时候同步代码块会带来比同步方法更好的效果。   追其同步的根本的目的，是控制竞争资源的正确的访问，因此只要在访问竞争资源的时候保证同一时刻只能一个线程访问即可，因此Java引入了同步代码快的策略，以提高性能。   在上个例子的基础上，对oper方法做了改动，由同步方法改为同步
java多线程同步块（synchronized(Object o){})的一个例程
zgrjkflmkyc的专栏
12-16 2203
java多线程同步块的一个例程，觉得对于理解同步快很有好处，分享之 源代码： class Produer implements Runnable { Q q; public Produer(Q q){ this.q=q; } public void run(){ int i=0; while(true){ synchronized(q){ if( i==0){
java 线程同步块_java基础——线程同步块
weixin_39537397的博客
02-15 59
package synchronization.block;/*@author zsben@create 2020-01-03 13:48创建三个窗口卖票，使用Runnable接口方式1.问题：卖票过程中出现了重票，错票-->出现了线程安全问题2.解决方案：当一个线程在操作ticket时，其他线程不能参与进来(即使该线程被阻塞)直到该线程操作完ticket，其他线程才可以参与进来，3.jav...
（六）java并发编程--synchronized同步块
Xinghf
11-24 1925
虽然前面文章的一些实例中已经使用synchronized关键字来实现线程的同步，但还是需要好好的理解一下。 [TOC] java synchronized 关键字 synchronized实例方法 synchronized静态方法 实例方法中的同步块 静态方法中的同步块 java synchronized 实例(安全初始化模式实例) java并发应用程序
java线程同步synchronized
最新发布
07-27
Java中的线程同步是通过关键字synchronized来实现的。synchronized关键字可以应用在方法或代码块上，用于实现线程安全。当一个线程获取了某个对象的锁，其他试图获取该对象锁的线程将被阻塞，直到该线程释放锁。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值