Java 多线程学习（五）-阿里云开发者社区

4.2 同步方法

这个博客很好，可参考：synchronized的四种用法修饰方法 Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来

由于我们可以通过关键字 private 关键字来保证数据对象只能被方法访问，所以我们只要针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种方法：

synchronized 方法和 synchronized 块.

同步方法:

public synchronized void method(int args){}
• 1

synchronized 方法控制 “对象” 的访问，每个对象对应一把锁，每个 synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法申明为 synchronized 将会影响效率。

Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，
synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，
修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。
例如：
方法一
public synchronized void method()
{
   // todo
}
方法二
public void method()
{
   synchronized(this) {
      // todo
   }
}
写法一修饰的是一个方法，写法二修饰的是一个代码块，但写法一与写法二是等价的，
锁的对象都是方法的调用者，就是当前类的实例化对象

使用synchronized 同步方法（同步方法中无需指定同步监视器，因为同步方法的同步监视器默认就是 this ，就是当前类的对象，如果是静态同步方法就是当前类Class）

package com.can.syn;
//不安全的买票
//线程不安全
//"苦逼的我"，"牛逼的你"，"可恶黄牛"可能会拿到同一张票，甚至在最后一张票的时候可能都会将最后一张票执行，就会有-1
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 ticketNums = 10; //票
    private boolean flag = true; //外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
 //此处加油synchronized 更好的解决 线程不安全的问题 加入之后正常
    private synchronized void buy() throws InterruptedException {
        //判断是否有票
        if(ticketNums<=0){
            flag = false;
            return;
        }
        //模拟延时
        Thread.sleep(10);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

扩展：多线程抢票系统浅析

4.3 同步块

同步块：synchronized(Obj){}

Obj 称之为同步监视器

Obj 可以是任何对象，但是推荐使用共享资源作为同步监视器
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是 this ，就是当前类的对象本身，如果是静态同步方法就是当前类Class
同步监视器的执行过程

第一个线程访问，锁定同步监视器，执行其中的代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，发现同步监视器没有锁，然后锁定并访问

当我们需要锁指定的对象（Account）时就需要使用同步块，我们如果使用同步方法锁，锁run()方法，默认会锁住this，即Drawing对象，这不是我们想锁的，所以我们使用同步块。

锁的是发生变化的量

package com.can.syn;
import lombok.experimental.Accessors;
//不安全的取钱
//两个人去银行取钱，账户
public class UnsafeBank {
    public static void main(String[] args) {
        //账户
        Account account = new Account(100,"结婚基金");
        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");
        you.start();
        girlFriend.start();
    }
}
//账户
class Account{
    public int money; //余额
    public 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(Thread.currentThread().getName()+"余额不足，取不了");
            //余额不够取得钱，return
            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);
        //Thread.currentThread().getName() = this.getName,因为继承了Thread，所以有Thread的全部方法
        System.out.println(this.getName()+"手里的钱:"+nowMoney);
    }
}
}

静态方法中的同步块

下面是两个静态方法同步的例子。这些方法同步在该方法所属的类对象上。

public class MyClass {
    public static synchronized void log1(String msg1, String msg2){
       log.writeln(msg1);
       log.writeln(msg2);
    }
    public static void log2(String msg1, String msg2){
       synchronized(MyClass.class){
          log.writeln(msg1);
          log.writeln(msg2);
       }
    }
  }

这两个方法不允许同时被线程访问。

如果第二个同步块不是同步在 MyClass.class 这个对象上。那么这两个方法可以同时被线程访问。

4.3 死锁

多个线程各自占有一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。某一个同步块同时拥“两个以上对象的锁”时，就可能会发生“死锁”的问题。

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用。
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺。
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系。

上述四个条件，只要破坏其任意一个就可避免死锁的发生。

死锁演示：

package com.example.democrud.democurd.test01;
//死锁：多个线程互相用者对象需要的资源，互不释放相互僵持
public class DeadLock {
}
//口红
class Lipstick {
}
//镜子
class Mirror {
    public static void main(String[] args) {
        Makeup makeupA = new Makeup(0,"A女孩");
        Makeup makeupB = new Makeup(1,"B女孩");
        makeupA.start();
        makeupB.start();
    }
}
class Makeup extends Thread {
    //需要的资源只有一份，用static来保证只有一份
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    int choice;//选择
    String girlName;//使用化妆品的人
    Makeup(int choice,String girlName){
        this.choice=choice;
        this.girlName=girlName;
    }
    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //化妆 互相持有对方的锁
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
                //1s后他下拿到镜子
                synchronized (mirror) {
                    System.out.println(this.girlName + "获得镜子的锁");
                }
            }
        } else {
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(1000);
                synchronized (lipstick) {
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

此处就是死锁；他们互相拿着对方需要的东西；互补撒手；你等我我等你；…

避免代码：

//化妆 互相持有对方的锁
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得口红的锁");
                Thread.sleep(1000);
                //1s后他下拿到镜子
            }
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
            }
        } else {
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子的锁");
                Thread.sleep(1000);
            }
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得口红的锁");
            }
        }
    }

4.4 Lock（可重入锁）

从 JDK 5.0 开始，Java 提供了更强大的线程同步机制——通过显示定义同步锁对象来实现同步。同步锁使用 Lock对象充当
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象
ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock ，可以显示加锁、释放锁。

synchronized 与 Lock 的对比

Lock 是显示锁（手动开启和关闭），synchronized 是隐式锁，出了作用域自动释放
Lock 只有代码加锁，synchronized 有代码块锁和方法锁
使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并具有更好的扩展性（提供更多的子类）
Lock > 同步代码块（已经进入了方法体，分配了相应资源）>同步方法（在方法体之外）

package com.example.democrud.democurd.test01;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
    public static void main(String[] args) {
        Testlock2 testlock2 = new Testlock2();
        new Thread(testlock2, "A").start();
        new Thread(testlock2, "B").start();
        new Thread(testlock2, "C").start();
    }
}
class Testlock2 implements Runnable {
    // 10张票
    int tickNums = 10;
    //定义lock锁 私有不可变
    private final ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            try {
                //打开锁
                lock.lock();
                if (tickNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "的票" + tickNums--);
                } else {
                    break;
                }
            } finally {
                lock.unlock(); //关闭锁
            }
        }
    }
}

Java 多线程学习（五）

4.2 同步方法

4.3 同步块

锁的是发生变化的量

静态方法中的同步块

4.3 死锁

4.4 Lock（可重入锁）

热门文章

最新文章

相关课程

相关电子书

相关实验场景