线程同步

本文主要是介绍线程同步，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

线程同步

并发

同一个对象被多个线程同时操作
形成条件

队列 + 锁
由于同一个进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized,当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。存在以下问题：
- 一个线程持有锁会导致其他所有需要此锁的线程挂起
- 在多个线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延迟时，引起性能问题
- 如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题
  三大不安全的案例

//不安全的买票
//线程不安全，有重复或者负数
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 ticketnum = 10;
    boolean flag = true;//外部停止标志

    @Override
    public void run() {
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            buy();
        }
    }
    public void buy() {
        if(ticketnum <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "买到了" + ticketnum--);
    }
}

package com.GGp.Demo1;

//不安全的取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");
        Drawing you = new Drawing(account, 50, "小明");
        Drawing me = new Drawing(account, 100, "小红");
        you.start();
        me.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(Account account,int drawingMoney,String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }
    //取钱

    @Override
    public void run() {
            if(account.money-drawingMoney<0) {
                System.out.println(this.getName() +"钱不够取了");
                return;
            }
            //模拟延迟 放大错误
            try {
                Thread.sleep(1000);
            } 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);
    }
}

/线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()-> {
                    list.add(Thread.currentThread().getName());
            }).start();
        }
        System.out.println(list.size());
    }
}

同步方法

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块。
- 同步方法：public synchronized void method(int args){}
synchronized方法控制对“对象”的访问，每一个对象对应一把锁，每一个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦调用，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
- 缺陷：若将一个大的方法申明为synchronized将会影响效率

同步块：synchronized(Obj){}

Obj称之为 同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象的本身，或者是class
同步监视器执行的过程：
1. 第一个线程访问，锁定同步监视器，执行其中的代码
2. 第二个线程访问，发现同步监视器被锁定，无法访问
3. 第一个线程访问完毕，解锁同步监视器
4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
  使得线程安全的改进

//不安全的买票的改进
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 ticketnum = 10;
    boolean flag = true;//外部停止标志

    @Override
    public void run() {
        while (flag) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            buy();
        }
    }
    public synchronized void buy() {
        if(ticketnum <= 0) {
            flag = false;
            return;
        }
        System.out.println(Thread.currentThread().getName() + "买到了" + ticketnum--);
    }
}

//不安全的取钱的改进
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "基金");
        Drawing you = new Drawing(account, 50, "小明");
        Drawing me = new Drawing(account, 100, "小红");
        you.start();
        me.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(Account account,int drawingMoney,String name) {
        super(name);
        this.account = account;
        this.drawingMoney = drawingMoney;
    }
    //取钱

    @Override
    public void run() {
        synchronized (account) {
            if(account.money-drawingMoney<0) {
                System.out.println(this.getName() +"钱不够取了");
                return;
            }
            //模拟延迟 放大错误
            try {
                Thread.sleep(1000);
            } 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);
        }

    }
}

//线程不安全的集合的改进
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()-> {
                synchronized (list){
                    list.add(Thread.currentThread().getName());
                }

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

总结
使用同步块时，锁住的时要改变的量，例如案例中的整个账户信息

这篇关于线程同步的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程

线程同步

线程同步

同步方法

同步块：synchronized(Obj){}

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯