浅析Java中synchronized与static synchronized

最新推荐文章于 2024-04-27 09:13:51 发布
最新推荐文章于 2024-04-27 09:13:51 发布
阅读量541 收藏
点赞数
分类专栏： 多线程 文章标签： java
原文链接：http://t.zoukankan.com/liuyang0-p-6679169.html
版权

synchronized关键字

synchronized是进行同步处理而保证线程安全。在一个方法中，如果是方法内的私有变量，那个这个变量是线程安全的，但是类中的实例变量是可能会出现线程安全问题的，当多个线程对这个实例变量进行修改，就可能会出现结果并不是我们期望的结果。

线程安全问题

下面一段代码就出现了线程安全问题。
本来当username为a的时候，num应该为100，但是由于设置让t1休眠了2秒，导致num被刷新成了200，导致最后输出时a和b的num都是200。

public class Service {
    private int num = 0;
    public void add(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                Thread.sleep(2000);
            } else {
                num = 200;
            }
            System.out.println(username + " " + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.add("a");
    }
}

public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.add("b");
    }
}

public class Test {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA t1 = new ThreadA(service);
        ThreadB t2 = new ThreadB(service);
        t1.start();
        t2.start();
    }
}

运行结果：

synchronized锁

下面给add方法加个synchronized关键字。
可以看到输出正确。
synchronized进行了同步，使得线程按照顺序进行访问，由于线程t1和t2的监视器都是同一个实例，相当于拥有同一个锁对象，所以可以进行同步访问。

public class Service {
    private int num = 0;
    public synchronized void add(String username) {
        try {
            if (username.equals("a")) {
                num = 100;
                Thread.sleep(2000);
            } else {
                num = 200;
            }
            System.out.println(username + " " + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出结果：

synchronized同步代码块

上面的代码中是使用synchronized将整个方法进行上锁，只有当一个方法执行完毕后，另一个线程才可以执行这个方法，这样会导致性能损耗很大。
返回到线程安全问题，目的其实是为了解决对临界资源访问的问题，所以其实只需要将临界资源进行上锁就可以了，其他部分其实是可以异步进行的。

在下面代码中，doSomeTask方法里前半部分没有进行同步，后面使用了同步代码块进行加锁。
从输出结果可以看到，前面部分A、B两个线程是异步进行访问的，后部分是同步进行访问的。

public class Service {
    public  void doSomeTask(String username) {
        for (int i = 0; i < 5; i++) {
            System.out.println("没有同步 " + Thread.currentThread().getName() + " " + i);
        }
        System.out.println();
        synchronized (this) {
            for (int i = 0; i < 5; i++) {
                System.out.println("同步了" + Thread.currentThread().getName() + " " + i);
            }
        }
    }
}

public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.doSomeTask("a");
    }
}

public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.doSomeTask("b");
    }
}

public class Test {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA t1 = new ThreadA(service);
        ThreadB t2 = new ThreadB(service);
        t1.setName("A");
        t2.setName("B");
        t1.start();
        t2.start();
    }
}

运行结果：

所以使用synchronized同步代码块可以将需要加锁的部分进行上锁就行了，这样可以提高性能。
可以使用synchronized同步代码块加锁临界资源，这样就可以避免出现线程安全问题。
在JDK1.8中的ConcurrentHashMap也使用synchronized锁，synchronized锁的性能已经有了很大的提高。

static synchronized

static方法为类方法，那么对static方法加上synchronized锁后呢？加锁的究竟是什么呢？
其实这时候监视器上锁的对象为这个类对象，而不是一个具体的实例对象，就是所有该类的实例访问这个方法都会进行加锁。

从下面实例可以看出，虽然是两个实例四个线程访问该方法，但是还是进行了同步，因为所有实例访问的是同一把锁，也就是Service类的对象锁，只要是监视器锁对象是同一个，那么都是会进行上锁同步的。

public class Service {
    public static synchronized void doSomeTask(String username) {
        for (int i = 0; i < 5; i++) {
            System.out.println("同步了" + Thread.currentThread().getName() + " " + i);
        }
    }
}

public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.doSomeTask("a");
    }
}

public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.doSomeTask("b");
    }
}


public class Test {
    public static void main(String[] args) {
        Service service = new Service();
        Service service1 = new Service();
        ThreadA t1 = new ThreadA(service);
        ThreadB t2 = new ThreadB(service);
        ThreadA t3 = new ThreadA(service1);
        ThreadB t4 = new ThreadB(service1);
        t1.setName("A");
        t2.setName("B");
        t3.setName("C");
        t4.setName("D");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果：

使用同步代码块也可以实现上述功能。

在同步代码块中，将监视的锁对象设置为Service.class，代表监视的是这个类锁，所以也对这个类进行加锁同步。

public class Service {
    public void doSomeTask(String username) {
        synchronized (Service.class) {
            for (int i = 0; i < 5; i++) {
                System.out.println("同步了" + Thread.currentThread().getName() + " " + i);
            }
        }
    }
}

synchronized与static synchronized一起使用

四个线程访问两个方法，线程A和C访问task1，是一个普通的synchronized方法，线程B和D访问task2，是一个static synchronized方法。

从输出结果中可以看出，A、C进行了同步，B、D也进行同步，但是B和C在一开始是交替出现输出，代表B和C其实没有同步，就证明它们的锁不是同一把锁。

A和C线程获取的实例的对象锁，而B和D线程获取的是这个类的锁。

public class Service {
    public synchronized void task1() {
        for (int i = 0; i < 5; i++) {
            System.out.println("task1 " + Thread.currentThread().getName() + " " + i);
        }
    }

    public static synchronized void task2() {
        for (int i = 0; i < 5; i++) {
            System.out.println("task2 " + Thread.currentThread().getName() + " " + i);
        }
    }
}

public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.task1();
    }
}

public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service) {
        this.service = service;
    }

    @Override
    public void run() {
        super.run();
        service.task2();
    }
}

public class Test {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA t1 = new ThreadA(service);
        ThreadB t2 = new ThreadB(service);
        ThreadA t3 = new ThreadA(service);
        ThreadB t4 = new ThreadB(service);
        t1.setName("A");
        t2.setName("B");
        t3.setName("C");
        t4.setName("D");
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

运行结果：

综上：

  • synchronized同步代码块的性能比synchronized同步方法性能好。
  • 线程间的同步主要是看的获取的是什么锁，只有需要获取同一把锁的线程才会进行同步。
  • static synchronized获取的是类对象锁，而普通的synchronized获取的是实例对象的锁，所以其实他们不是同一把锁。
  • static synchronized的类对象锁可以对所有该类实例进行同步，因为所有该类实例获取的类锁都是同一把锁。
C18298182575
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅析java并发中的Synchronized关键词
08-25
主要介绍了java并发中的Synchronized关键词,本文通过思路代码给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
【Java多线程】 静态同步synchronized方法与synchronized(class)代码块
热门推荐
一定要站在自己热爱的生活里闪闪发光
10-13 4万+
8. 静态同步synchronized方法与synchronized(class)代码块 关键字synchronized还可以应用static静态方法上，如果这样写，那是对当前的.java文件对应的Class类进行持锁。* 下面通过通过例子说明一下用法与效果。 (1) Service.java public class Service { synchronized public static void printA() { try { System.out.println("线程名称为：" +
Java Synchronized 和 Static 关键字的总结与使用
qq_36883397的博客
11-29 604
一、Synchronized 同步锁的使用与注意事项 synchronized的4种用法 Synchronized即同步锁，主要应用在多线程之间同步作用，下面是Synchronized的四种使用方法。 1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在sy
synchronized与static synchronized详解
博学de叫兽
10-31 1万+
synchronized与static synchronized的区别 synchronized是实例锁，对类的当前实例进行加锁，防止其他线程同时访问该类的该实例的所有synchronized块。 注意这里是类的当前实例， 类的两个不同实例就没有这种约束了 static synchronized是类锁，控制类的所有实例的并发访问，限制多线程中该类的所有实例同时访问JVM中该类所对应的代...
java synchronized静态同步方法与非静态同步方法，同步语句块
wwwwwww31311的博客
01-30 2546
对代码进行同步控制我们可以选择同步方法，也可以选择同步块，这两种方式各有优缺点。同步块不仅可以更加精确的控制对象锁，还可以控制锁的作用域，何谓锁的作用域？锁的作用域就是从锁被获取到其被释放的时间。而且可以选择要获取哪个对象的对象锁。但是如果在使用同步块机制时，如果使用过多的锁也会容易引起死锁问题，同时获取和释放所也有代价，而同步方法，它们所拥有的锁就是该方法所属的类的对象锁，换句话说，也就是this对象，而且锁的作用域也是整个方法，这可能导致其锁的作用域可能太大，也有可能引起死锁，同时因为可能包含了不需要进
深入理解Synchronized（对象锁）和Static Synchronized（类锁）的区别
Darling_qi的博客
03-20 1608
通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）。
static 与 synchronized修饰同一个方法
zjyfree的博客
12-09 756
学习笔记
Java中synchronized正确使用方法解析
08-25
主要介绍了Java中syncronized正确使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java 中 synchronized的用法详解(四种用法)
09-03
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。本文给大家介绍java中 synchronized的用法，对本文感兴趣的朋友一起看看吧
synchronized与static synchronized的区别
01-20
大家在学习java多线程的时候肯定会遇到这个...static synchronized这个是“全局锁”或者是“类锁”，该锁针对的是类，不管实例了多少个对象，线程都共享该锁。 下面我们来看代码： import java.util.concurrent.TimeUni
透彻理解Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别
08-27
主要介绍了Java中Synchronized（对象锁）和Static Synchronized（类锁）的区别，希望对大家有所帮助，一起跟随小编过来看看吧
java 静态同步锁static synchronized详解
hello_v_world的博客
07-07 2179
下面我们看例子1： 有一个phone类，里面有两个同步方法（synchronized修饰），分别为发送email和发送短信，在main方法中实例化一部手机，开启两个线程去操作phone这个资源类 public class Phone { public synchronized void sendMail() throws Exception { TimeUnit.SECONDS.sleep(4); System.out.println("******sendMail
Java中synchronized 用在static方法和非static方法上面的区别
Alen
08-20 2547
在Java中，synchronized是用来表示同步的，我们可以synchronized来修饰一个方法。也可以synchronized来修饰方法里面的一个语句块。那么，在static方法和非static方法前面加synchronized到底有什么不同呢？大家都知道，static的方法属于类方法，它属于这个Class（注意：这里的Class不是指Class的某个具体对象），那么static获取到的锁......
Synchronized同步静态方法和非静态方法总结
奔跑入坑大数据
11-16 1787
1.Synchronized修饰非静态方法，实际上是对调用该方法的对象加锁，俗称“对象锁”。 Java中每个对象都有一个锁，并且是唯一的。假设分配的一个对象空间，里面有多个方法，相当于空间里面有多个小房间，如果我们把所有的小房间都加锁，因为这个对象只有一把钥匙，因此同一时间只能有一个人打开一个小房间，然后用完了还回去，再由JVM 去分配下一个获得钥匙的人。 情况1：同一个对象在两个线程中分别访问该对象的两个同步方法 结果：会产生互斥。 解释：因为锁针对的是对象，当对象调用一个synch...
多线程synchronized和synchronized static方法的区别
qianyiyiding的专栏
09-10 3328
synchronized static和synchronized 关键字1.synchronized satic 方法，如果是一个方法加上static关键字和synchronized。static一定不属于任何对象，属于一个类。那么它锁的是当前类的对象的class对象。因为Java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象,因为当前线程分别访问了同一个类的两个对象的static，
synchronized与static synchronized
zy139的博客
02-28 1351
概述 我们可能对synchronized了解，对static也不陌生（Java static关键字），但是对两者的结合 static synchronized可能不太了解。在一些面试中，会问及synchronized与static synchronized的区别 区别 synchronized关键字 synchronized作用是对类的当前实例（对象）加锁。可以使用synchronized关键字来...
Synchronized（对象锁）和Static Synchronized（类锁）的区别
cs408的博客
10-06 3万+
Synchronized和Static Synchronized区别 通过分析这两个用法的分析，我们可以理解java中锁的概念。一个是实例锁（锁在某一个实例对象上，如果该类是单例，那么该锁也具有全局锁的概念），一个是全局锁（该锁针对的是类，无论实例多少个对象，那么线程都共享该锁）。实例锁对应的就是synchronized关键字，而类锁（全局锁）对应的就是static synchroniz
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 1062
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
java中synchronized
03-20
Java中的synchronized关键字是一种用于实现线程同步和互斥的机制[^2]。它可以应用于代码块或方法上，以确保多个线程在访问共享资源时不会发生冲突。下面是关于Java中synchronized的一些特性： 1. 线程安全：使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值