Java并发之synchronized关键字

     上篇文章我们主要介绍了并发的基本思想以及线程的基本知识,通过多线程我们可以实现对计算机资源的充分利用,但是在最后我们也说明了多线程给程序带来的两种典型的问题,针对它们,synchronized关键字可以很好的解决问题。对于synchronized的介绍主要包含以下一些内容:

  • synchronized修饰实例方法
  • synchronized修饰静态方法
  • synchronized修饰代码块
  • 使用synchronized解决竞态条件问题
  • 使用synchronized解决内存可见性问题

一、使用synchronized关键字修饰实例方法      在我们的Java中,每个对象都有一把锁和两个队列,一个用于挂起未获得锁的线程,一个用于挂起条件不满足而不得不等待的线程。而我们的synchronized实际上也就是一个加锁和释放锁的集成。先看个例子:

/*定义一个计数器类*/
public class Counter {
    private int count;

    public synchronized int getCount(){return this.count;}

    public synchronized void addCount(){this.count++;}
}
/*定义一个线程类*/
public class MyThread extends Thread{

    public static Counter counter = new Counter();

    @Override
    public void run(){
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        counter.addCount();
    }
}
/*main方法启动100个线程*/
public static void main(String[] args){
        Thread[] threads = new Thread[100];
        for (int i=0;i<100;i++){
            threads[i] = new MyThread();
            threads[i].start();
        }

        for (int j=0;j<100;j++){
            threads[j].join();
        }

        System.out.println(MyThread.counter.getCount());
    }

上述程序无论运行多少次,结果都是一样的。

这是一个典型的使用synchronized关键字修饰实例方法来解决竞态条件问题的示例。首先在我们定义的线程类中,我们定义了一个Counter实例,然后让以后的每个线程在运行的时候都先随机睡眠,然后调用这个公共变量count的自增方法,只不过该自增方法是有synchronized关键字修饰的。我们说过每个对象都有锁和两个队列,这里的count实例就是一个对象,这一百个线程每次在睡醒之后都要调用count的addCount方法,而所有要调用addCount方法的线程都必须先获得count这个对象的锁,也就是说,如果有一个线程获取了count对象的锁并开始调用addCount方法时,其他线程都得阻塞在该对象的一个队列上,等待获得锁的线程执行结束释放锁。

所以,在同一时刻,只可能有一个线程获得count的锁并对其进行自增操作,其他的线程都在该对象的阻塞队列上进行等待,自然是不会出现多个线程在某个时间段同时操作同一个变量而引起该变量数据值不正确的情况。

二、使用synchronized关键字修饰静态方法      对于静态方法,其实和实例方法是类似的。只不过synchronized关键字对实例方法而言,它获得的是实例对象的锁,所有共享相同该对象的线程都必须先获得该对象的锁。而对于静态方法而言,synchronized关键字获得的是类的锁,也就是对于所有需要访问相同类的线程都是需要先获得该类的锁的,否则将需要在某个阻塞队列上进行等待。

/*定义一个线程类*/
public class MyThread extends Thread{

    public static int count;

    public synchronized static void addCount(){
        count++;
    }
    @Override
    public void run(){
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        addCount();
    }
}
/*启动100个线程*/
public static void main(String[] args) throws InterruptedException {
        Thread[] threads = new Thread[100];
        for (int i=0;i<100;i++){
            threads[i] = new MyThread();
            threads[i].start();
        }

        for (int j=0;j<100;j++){
            threads[j].join();
        }

        System.out.println(MyThread.count);
    }

程序基本和我们的第一个例子相差无几,在线程类中我们定义了一个静态变量和一个静态方法,该方法被synchronized关键字修饰,然后run方法依然是让当前线程随机睡眠,然后调用这个被synchronized关键字修饰的静态方法。我们可以看到,无论运行多少次的程序,结果都是一样。

每个线程在睡醒之后,都要去调用addCount方法,而调用该方法前提是要获取到类Count的锁,如果获取不到就必须在该对象的阻塞队列上进行等待。所以一次只会有一个线程调用addCount方法,自然是无论运行多少次,结果都会是100。

三、使用synchronized关键字修饰代码块      使用synchronized关键字修饰一段代码块和上述介绍的两种情况略微有点不同。对于实例方法,synchronized关键字总是尝试去获取某个对象的锁,对于静态方法,synchronized关键字始终尝试去获取某个类的锁,而对于我们的代码块,它就需要显式指定以谁为锁了。例如:

/*定义一个线程类*/
public class MyThread extends Thread{

    public static Integer count = 0;

    @Override
    public void run(){
        try {
            Thread.sleep((int)(Math.random()*100));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (count){
            count++;
        }
    }
}

在我们定义的线程类中,我们定义了一个静态变量count,而每个线程在醒来之后都会去尝试着去获取该对象的锁,如果得不到就阻塞在该对象的阻塞队列上等待锁的释放。实际上这里的synchronized关键字利用的就是对象count的锁,我们上述介绍的两种形式,synchronized关键字修饰在实例方法和静态方法上,默认利用的是类对象的锁和类的锁。例如:

public synchronized void show(){....} 

调用show方法等价于:

synchronized(this){
    public void show(){...}
}

而对于静态方法:

public class A{
    public synchronized static void show(){....}
}

等价于:

synchronized(A.class){
    public static void show(){....}
}

四、使用synchronized关键字解决内存可见性问题      通过了解了synchronized应用的三种不同场景,我们对它应该有了大致的一个了解。下面我们使用它解决上篇提到的多线程的一个问题 ----- 内存可见性问题。至于竞态条件问题已经在第一小节间接的进行介绍了,此处不再赘述。这里我们再简单重复下内存可见性问题,因为我们的CPU是有缓存的,所以当一个线程在运行的时候,有些变量值的修改并没有立马写回内存,而是缓存在各级缓存中,这就导致其他线程访问这个公共变量的时候就拿不到最新的值,因此导致数据的值偏差,计算结果不准确。我们看看一个例子:

/*定义一个线程类,并定义一个共享的变量count*/
public class MyThread extends Thread{

    public static int count = 0;

    @Override
    public void run(){
        while (count==0){
            //running
        }
        System.out.println("mythread exit");
    }
}
/*main函数启动一个线程*/
public static void main(String[] args) throws InterruptedException {
        Thread thread = new MyThread();
        thread.start();

        Thread.sleep(1000);

        MyThread.count = 1;
        System.out.println(MyThread.count);
        System.out.println("exit main");

    }

我们在定义的线程类中定义了一个共享变量,run方法主要的工作是循环等待count不为0,而我们在main线程中修改了这个count的值,由于循环这个操作是比较频繁的判断条件的,所以该线程并不会每次都从内存中取出count的值,而是在它的缓存中取,所以主线程对count的修改,在thread线程中是始终看不见的。所以我们的程序输出的结果如下:

主线程在修改count的值之后,输出显示的确count的值为1,然后主线程退出,但是我们发现程序却没有结束,thread的退出信息也没有被打印。也就是说线程thread还被困在了while循环中,虽然main线程已经修改了count的值。这就是内存可见性问题,主要是由于多线程之间进行通讯的桥梁是内存,而各个线程内部又有各自的缓存,如果对公共变量的的修改没有及时更新到内存的话,那么就很容易导致其他线程访问的是数据不是最新的。

我们使用synchronized关键字解决上述问题:

public class MyThread extends Thread{

    public static int count = 0;

    public synchronized static int returnCount(){return count;}
    
    @Override
    public void run(){
        while(returnCount()==0){

        }
        System.out.println("mythread exit");
    }
}

我们使用synchronized关键修饰了一个方法,该方法返回count的值。jvm对synchronized的两条规定,其一是线程在解锁之前必须把所有共享变量刷新到内存中,其二是线程在释放锁的时候将清空所有的缓存迫使本线程在使用该共享变量的时候从内存中去读取。这样就可以保证每次对共享变量的读取都是最新的。

当然如果仅仅是为了解决内存可见性问题而使用synchronized关键字的话,会有点大材小用。毕竟synchronized的成本开销相对而言是较大的。Java中提供了一个volatile关键字用于解决这种内存可见性问题。例如:

public static volatile int count = 0;

像这样,我们只需要在某个变量前面加上修饰符 volatile 即可让该变量在被读的时候从内存去取,也就是保持最新数据值以实现对内存可见性问题的解决。

至此,我们简单的介绍了synchronized关键字的一些基本用法,介绍了它可以修饰的场景,以及使用它来解决我们的两个典型的多线程问题。下篇文章我们将着重介绍线程间的协作机制。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏蓝天

如何解决fd跨线程安全问题

fd跨线程是不安全的,当一个线程close它后,就相当于成了野指针,另一线程再使用就成了对野指针的使用,当系统调用使用一个已经close后的fd时,可能出现内核...

421
来自专栏python3

python3--threading模块(线程)

程序并不能单独运行,只有将程序装载到内存中,系统为它分配资源才能运行,而这种执行的程序就称之为进程。程序和进程的区别就在于:程序是指令的集合,它是进程运行的静态...

1182
来自专栏Android中高级开发

Android并发编程 开篇

该文章是一个系列文章,是本人在Android开发的漫漫长途上的一点感想和记录,我会尽量按照先易后难的顺序进行编写该系列。该系列引用了《Android开发艺术探索...

502
来自专栏企鹅号快讯

Python的线程

本文是基于Py2.X 线程 多任务可以由多进程完成,也可以由一个进程内的多线程完成。 我们前面提到了进程是由若干线程组成的,一个进程至少有一个线程。 多线程类似...

1848
来自专栏技术小站

Python 多线程与多进程

原文地址:http://www.cnblogs.com/whatisfantasy/p/6440585.html

912
来自专栏hbbliyong

C#基础知识回顾--线程传参

  在不传递参数情况下,一般大家都使用ThreadStart代理来连接执行函数,ThreadStart委托接收的函数不能有参数, 也不能有返回值。如果希望传递参...

2716
来自专栏技术小站

搞定python多线程和多进程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流,一个进程中可以并发多个线程,每条...

611
来自专栏JAVA同学会

Zookeeper应用之——队列(Queue)

为了在Zookeeper中实现分布式队列,首先需要设计一个znode来存放数据,这个节点叫做队列节点,我们的例子中这个节点是/zookeeper/queue。

882
来自专栏程序猿DD

Spring Boot使用@Async实现异步调用:使用Future以及定义超时

之前连续写了几篇关于使用 @Async实现异步调用的内容,也得到不少童鞋的反馈,其中问题比较多的就是关于返回 Future的使用方法以及对异步执行的超时控制,所...

1133
来自专栏大数据架构

Java进阶(二)当我们说线程安全时,到底在说什么

这一点,跟数据库事务的原子性概念差不多,即一个操作(有可能包含有多个子操作)要么全部执行(生效),要么全部都不执行(都不生效)。

44013

扫码关注云+社区