Java多线程(四) 解决多线程安全——synchronized

Java多线程(四) 解决多线程安全——synchronized

  • Java多线程(四) 解决多线程安全——synchronized
    • synchronized的使用
    • synchronized 是重量型锁
    • synchronized 原理和例子
      • synchronized 作用于实例方法
      • synchronized 作用于代码块
      • synchronized作用于静态方法
    • synchronized 可重入锁

在上一篇文章 《Java多线程(三) 多线程不安全的典型例子》中说到了多线程不安全的问题以及三个典型例子,在这一篇中讲解一中保证多线程安全的一种方式——synchronized关键字。

synchronized的使用

synchronized相当于给对象上锁或者给类上锁,这样防止其他线程访问共享资源,进而保护多线程的安全。synchronized的原理是它使用了flag标记ACC_SYN-CHRONIZED,执行线程先持有同步锁,然后执行方法,最后在方法完成时才释放锁。

synchronized主要有三种用法:

  1. 修饰实例方法:作用于当前对象实例加锁,进入同步代码前要获得当前对象实例的锁
synchronized void method() {
  //业务代码
}
  1. 修饰静态方法:也就是给当前类加锁,会作用于类的所有对象实例 ,进入同步代码前要获得当前 class 的锁。因为静态成员不属于任何一个实例对象,是类成员( static 表明这是该类的一个静态资源,不管 new 了多少个对象,只有一份),所以,如果一个线程 A 调用一个实例对象的非静态 synchronized 方法,而线程 B 需要调用这个实例对象所属类的静态 synchronized 方法,是允许的,不会发生互斥现象,因为访问静态 synchronized 方法占用的锁是当前类的锁,而访问非静态 synchronized 方法占用的锁是当前实例对象锁
synchronized void staic method() {
  //业务代码
}
  1. 修饰代码块:指定加锁对象,对给定对象/类加锁。synchronized(this / object) 表示进入同步代码库前要获得给定对象的锁。synchronized(类.class) 表示进入同步代码前要获得当前 class 的锁
synchronized(this) {
  //业务代码
}

总的来说:

synchronized 关键字加到 static 静态方法和 synchronized(class) 代码块上都是是给 Class 类上锁。

synchronized 关键字加到实例方法上是给对象实例上锁。

synchronized 是重量型锁

Synchronized是通过对象内部的一个叫做监视器锁(monitor)来实现的。但是监视器锁本质又是依赖于底层的操作系统的Mutex Lock来实现的。而操作系统实现线程之间的切换这就需要从用户态转换到核心态,这个成本非常高,状态之间的转换需要相对比较长的时间,这就是为什么Synchronized效率低的原因。因此,这种依赖于操作系统Mutex Lock所实现的锁我们称之为“重量级锁”。

synchronized 原理和例子

在 Java 中,synchronized可以保证在同一个时刻,只有一个线程可以执行某个方法或者某个代码块(主要是对方法或者代码块中存在共享数据的操作),此外synchronized的另外一个重要的作用是synchronized可保证一个线程的变化(主要是共享数据的变化)被其他线程所看到(保证可见性,完全可以替代Volatile功能),这点确实也是很重要的。

synchronized 作用于实例方法

第一个例子举一个很简单的对一个类的共享资源加一的操作,为了保证多线程安全,使用synchronized修饰increase()。对于增加i值来说,他并不是一个原子操作,因为第一步要读取i值,第二步要对他进行加一操作,因此需要进行互斥操作。synchronized修饰的是实例方法increase,在这样的情况下,当前线程的锁便是实例对象instance。当一个线程正在访问一个对象的 synchronized 实例方法,那么其他线程不能访问该对象的所有 synchronized 方法,因为一个对象只有一把锁,当一个线程获取了该对象的锁之后,其他线程无法获取该对象的锁,所以无法访问该对象的synchronized实例方法,这样的方式也就保护了多线程的安全,不过其他线程还是可以访问该实例对象的其他非synchronized方法。

public class syntest {

    public static void main(String[] args) throws InterruptedException {
        AccountingSync instance=new AccountingSync();
        Thread t1=new Thread(instance);
        Thread t2=new Thread(instance);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

class AccountingSync implements Runnable{
    static int i=0;

    public synchronized void increase() throws InterruptedException {
        i++;
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName()+"增加了i值,它的值为 "+i);
    }
    @Override
    public void run() {
        for(int j=0;j<100;j++){
            try {
                increase();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

Java多线程(四) 解决多线程安全——synchronized_第1张图片
(省略中间的)
Java多线程(四) 解决多线程安全——synchronized_第2张图片

synchronized 作用于代码块

这里举的例子是上一篇《Java多线程(三) 多线程不安全的典型例子》的第一个不安全的买票例子,这里依旧是三个人买票,一共三十张票,不同的是这次使用synchronized对买票的代码块进行上锁。当编写的方法体比较大时,同时存在一些比较耗时的操作,而需要同步的代码又只有一小部分,如果直接对整个方法进行同步操作,可能会得不偿失,此时我们可以使用同步代码块的方式对需要同步的代码进行包裹,这样就无需对整个方法进行同步操作了。将synchronized作用于一个给定的实例对象t,即当前实例对象就是锁对象每次当线程进入synchronized包裹的代码块时就会要求当前线程持有instance实例对象锁,如果当前有其他线程正持有该对象锁,那么新到的线程就必须等待。当然除了t作为对象外,我们还可以使用this对象(代表当前实例)或者当前类的class对象作为锁。

class Ticket implements Runnable{

    private int alltickets = 30;
    private boolean flag = true;

    @Override
    public void run() {
        while(alltickets>0) {
                synchronized (this) {
                    try {
                        Thread.sleep(300);
                        buy();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

        }
    }

    public void buy() throws InterruptedException {

        if(this.alltickets<=0)
        {
            System.out.println("没票可买了"+Thread.currentThread().getName());
            this.flag = false;
            return;
        }

        else
        {
            Thread.sleep(100);
            System.out.println(Thread.currentThread().getName()+"买了第"+this.alltickets--+"张票   ");

        }
    }

}

public class testThread {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Ticket t = new Ticket();
        new Thread(t, "小华同学").start();
        new Thread(t, "小明同学").start();
        new Thread(t, "黄牛").start();
        }

Java多线程(四) 解决多线程安全——synchronized_第3张图片
可以看到这次买票过程是有序的,并且没有出现买到重复票的问题

synchronized作用于静态方法

当synchronized作用于静态方法时,其锁就是当前类的class对象锁。由于静态成员不专属于任何一个实例对象,是类成员,因此通过class对象锁可以控制静态成员的并发操作。需要注意的是如果一个线程A调用一个实例对象的非static的synchronized方法,而线程B需要调用这个实例对象所属类的静态 synchronized方法,是允许的,不会发生互斥现象,因为访问静态 synchronized 方法占用的锁是当前类的class对象,而访问非静态 synchronized 方法占用的锁是当前实例对象锁。synchronized关键字修饰的是静态方法,其锁对象是当前类的class对象。注意代码中的increase2方法是实例方法,其对象锁是当前实例对象,如果别的线程调用该方法,将不会产生互斥现象,毕竟锁对象不同,但我们应该意识到这种情况下可能会发现线程安全问题(操作了共享静态变量i)。

public class syntest {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(new StaticTest());
        Thread t2=new Thread(new StaticTest());
        t1.start();t2.start();
        
    }
}

class StaticTest implements Runnable{
    static int i=0;

    /**
     * 作用于静态方法,锁是当前class对象,也就是StaticTest类对应的class对象
     */
    public static synchronized void increase() throws InterruptedException {
        i++;
        Thread.sleep(300);
        System.out.println(Thread.currentThread().getName()+"增加了i值,它的值为 "+i);
    }

    /**
     * 非静态,访问时锁不一样不会发生互斥
     */
    public synchronized void increase2(){
        i++;
    }

    @Override
    public void run() {
        for(int j=0;j<100;j++){
            try {
                increase();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

synchronized 可重入锁

关键字synchronized拥有重入锁的功能,即在使用synchronized时,当一个线程得到了一个对象锁后,再次请求此对象锁时是可以得到该对象锁的,意思是在一个synchronized方法或者代码块中,调用这个类的其他synchronized方法或者代码块时是可以做到的。

public class syntest {
    public static void main(String[] args) throws InterruptedException {

        Thread t1=new Thread(new StaticTest());

        t1.start();

    }
}

class StaticTest implements Runnable{
    public synchronized void method1()
    {
        System.out.println("method1");
        method2();
    }

    public synchronized void method2()
    {
        System.out.println("method2");
        method3();
    }

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


    @Override
    public void run() {
        method1();
    }
}

在这里插入图片描述

你可能感兴趣的:(Java多线程编程,java,多线程)