• 关于

    synchronized java锁

    的搜索结果

回答

首先synchronized是java内置关键字,在jvm层面,Lock是个java类; synchronized无法判断是否获取锁的状态,Lock可以判断是否获取到锁; synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ;b 线程执行过程中发生异常会释放锁),Lock需在finally中手工释放锁(unlock()方法释放锁),否则容易造成线程死锁; 用synchronized关键字的两个线程1和线程2,如果当前线程1获得锁,线程2线程等待。如果线程1阻塞,线程2则会一直等待下去,而Lock锁就不一定会等待下去,如果尝试获取不到锁,线程可以不用一直等待就结束了; synchronized的锁可重入、不可中断、非公平,而Lock锁可重入、可判断、可公平(两者皆可); Lock锁适合大量同步的代码的同步问题,synchronized锁适合代码少量的同步问题

问问小秘 2020-01-03 14:05:30 0 浏览量 回答数 0

问题

JAVA中synchronized的疑问?

蛮大人123 2019-12-01 20:04:12 1112 浏览量 回答数 1

回答

一.什么是sychronized sychronized是java中最基本同步互斥的手段,可以修饰代码块,方法,类. 在修饰代码块的时候需要一个reference对象作为锁的对象. 在修饰方法的时候默认是当前对象作为锁的对象. 在修饰类时候默认是当前类的Class对象作为锁的对象. synchronized会在进入同步块的前后分别形成monitorenter和monitorexit字节码指令.在执行monitorenter指令时会尝试获取对象的锁,如果此没对象没有被锁,或者此对象已经被当前线程锁住,那么锁的计数器加一,每当monitorexit被锁的对象的计数器减一.直到为0就释放该对象的锁.由此synchronized是可重入的,不会出现自己把自己锁死. 二.什么ReentrantLock 以对象的方式来操作对象锁.相对于sychronized需要在finally中去释放锁 三.synchronized和ReentrantLock的区别 除了synchronized的功能,多了三个高级功能. 等待可中断,公平锁,绑定多个Condition. 1.等待可中断 在持有锁的线程长时间不释放锁的时候,等待的线程可以选择放弃等待. tryLock(long timeout, TimeUnit unit) 2.公平锁 按照申请锁的顺序来一次获得锁称为公平锁.synchronized的是非公平锁,ReentrantLock可以通过构造函数实现公平锁. new RenentrantLock(boolean fair) 3.绑定多个Condition 通过多次newCondition可以获得多个Condition对象,可以简单的实现比较复杂的线程同步的功能.通过await(),signal(); 总的来说,lock更加灵活。 主要相同点:Lock能完成synchronized所实现的所有功能 不同: 1.ReentrantLock功能性方面更全面,比如时间锁等候,可中断锁等候,锁投票等,因此更有扩展性。在多个条件变量和高度竞争锁的地方,用ReentrantLock更合适,ReentrantLock还提供了Condition,对线程的等待和唤醒等操作更加灵活,一个ReentrantLock可以有多个Condition实例,所以更有扩展性。 2.ReentrantLock必须在finally中释放锁,否则后果很严重,编码角度来说使用synchronized更加简单,不容易遗漏或者出错。 3.ReentrantLock 的性能比synchronized会好点。 4.ReentrantLock提供了可轮询的锁请求,他可以尝试的去取得锁,如果取得成功则继续处理,取得不成功,可以等下次运行的时候处理,所以不容易产生死锁,而synchronized则一旦进入锁请求要么成功,要么一直阻塞,所以更容易产生死锁

万立超 2019-12-02 01:56:53 0 浏览量 回答数 0

阿里云高校特惠,助力学生创业梦!0元体验,快速入门云计算!

学生动手场景应用,快速了解并掌握云服务器的各种新奇玩法!

回答

. 在编写一个类时,如果该类中的代码可能运行与多线程环境下,就要考虑同步问题了。 会同时被多个线程访问的资源,就是竞争资源,也称为竞争条件。对于多线程共享的资源我们必须进行同步,以避免一个线程的改动被另一个线程所覆盖。 synchronized 关键字有两种作用域: 1> 某个对象实例内,synchronized aMethod(){}关键字可以防止多个线程访问对象的synchronized方法(如果一个对象有多个synchronized方法,只要一个线程访问了其中的一个synchronized方法,其它线程不能同时访问这个对象中任何一个synchronized方法)。这时,不同的对象实例的synchronized方法是不相干扰的。也就是说,其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法. 2> 是某个类的范围,synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法; Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。      一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。      二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。      三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。      四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部   分的访问都被暂时阻塞。      五、以上规则对其它对象锁同样适用. 2. synchronized 关键字,它包括两种用法:synchronized 方法和 synchronized 块。   synchronized 方法:通过在方法声明中加入 synchronized关键字来声明 synchronized 方法。如:   synchronized void accessVal(int newVal);   synchronized 方法控制对类成员变量的访问:每个类实例对应一把锁,每个 synchronized 方法都必须获得调用该方法的类实例的锁方能 执行,否则所属线程阻塞,方法一旦执行,就独占该锁,直到从该方法返回时才将锁释放,此后被阻塞的线程方能获得该锁,重新进入可执行 状态。这种机制确保了同一时刻对于每一个类实例,其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态(因为至多只有 一个能够获得该类实例对应的锁),从而有效避免了类成员变量的访问冲突(只要所有可能访问类成员变量的方法均被声明为 synchronized) 。  在 Java 中,不光是类实例,每一个类也对应一把锁,这样我们也可将类的静态成员函数声明为 synchronized ,以控制其对类的静态成 员变量的访问。  synchronized 方法的缺陷:若将一个大的方法声明为synchronized 将会大大影响效率,典型地,若将线程类的方法 run() 声明为 synchronized ,由于在线程的整个生命期内它一直在运行,因此将导致它对本类任何 synchronized 方法的调用都永远不会成功。当然我们可 以通过将访问类成员变量的代码放到专门的方法中,将其声明为 synchronized ,并在主方法中调用来解决这一问题,但是 Java 为我们提供 了更好的解决办法,那就是 synchronized 块。   synchronized 块:通过 synchronized关键字来声明synchronized 块。语法如下:  synchronized(syncObject) {   //允许访问控制的代码  }  synchronized 块是这样一个代码块,其中的代码必须获得对象 syncObject (如前所述,可以是类实例或类)的锁方能执行,具体机 制同前所述。由于可以针对任意代码块,且可任意指定上锁的对象,故灵活性较高。  对synchronized(this)的一些理解 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线 程必须等待当前线程执行完这个代码块以后才能执行该代码块。  二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized (this)同步代码块。  三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this) 同步代码块的访问将被阻塞。  四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个 object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。  五、以上规则对其它对象锁同样适用 3.打个比方:一个object就像一个大房子,大门永远打开。房子里有 很多房间(也就是方法)。 这些房间有上锁的(synchronized方法), 和不上锁之分(普通方法)。房门口放着一把钥匙(key),这把钥匙可以打开所有上锁的房间。 另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了,下面我们看看这些东西之间如何作用的。 在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法,否则这个key还有啥意义。当然也就不会有我们的这个主题了。 一个人想进入某间上了锁的房间,他来到房子门口,看见钥匙在那儿(说明暂时还没有其他人要使用上锁的 房间)。于是他走上去拿到了钥匙 ,并且按照自己 的计划使用那些房间。注意一点,他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连续使用两间上锁的房间, 中间他也要把钥匙还回去,再取回来。 因此,普通情况下钥匙的使用原则是:“随用随借,用完即还。” 这时其他人可以不受限制的使用那些不上锁的房间,一个人用一间可以,两个人用一间也可以,没限制。但是如果当某个人想要进入上锁的房 间,他就要跑到大门口去看看了。有钥匙当然拿了就走,没有的话,就只能等了。 要是很多人在等这把钥匙,等钥匙还回来以后,谁会优先得到钥匙?Not guaranteed。象前面例子里那个想连续使用两个上锁房间的家伙,他 中间还钥匙的时候如果还有其他人在等钥匙,那么没有任何保证这家伙能再次拿到。 (JAVA规范在很多地方都明确说明不保证,象 Thread.sleep()休息后多久会返回运行,相同优先权的线程那个首先被执行,当要访问对象的锁被 释放后处于等待池的多个线程哪个会优先得 到,等等。我想最终的决定权是在JVM,之所以不保证,就是因为JVM在做出上述决定的时候,绝不是简简单单根据 一个条件来做出判断,而是 根据很多条。而由于判断条件太多,如果说出来可能会影响JAVA的推广,也可能是因为知识产权保护的原因吧。SUN给了个不保证 就混过去了 。无可厚非。但我相信这些不确定,并非完全不确定。因为计算机这东西本身就是按指令运行的。即使看起来很随机的现象,其实都是有规律 可寻。学过 计算机的都知道,计算机里随机数的学名是伪随机数,是人运用一定的方法写出来的,看上去随机罢了。另外,或许是因为要想弄 的确定太费事,也没多大意义,所 以不确定就不确定了吧。) 再来看看同步代码块。和同步方法有小小的不同。 1.从尺寸上讲,同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间。 2.同步代码块还可以人为的指定获得某个其它对象的key。就像是指定用哪一把钥匙才能开这个屏风的锁,你可以用本房的钥匙;你也可以指定 用另一个房子的钥匙才能开,这样的话,你要跑到另一栋房子那儿把那个钥匙拿来,并用那个房子的钥匙来打开这个房子的带锁的屏风。          记住你获得的那另一栋房子的钥匙,并不影响其他人进入那栋房子没有锁的房间。          为什么要使用同步代码块呢?我想应该是这样的:首先对程序来讲同步的部分很影响运行效率,而一个方法通常是先创建一些局部变 量,再对这些变量做一些 操作,如运算,显示等等;而同步所覆盖的代码越多,对效率的影响就越严重。因此我们通常尽量缩小其影响范围。 如何做?同步代码块。我们只把一个方法中该同 步的地方同步,比如运算。          另外,同步代码块可以指定钥匙这一特点有个额外的好处,是可以在一定时期内霸占某个对象的key。还记得前面说过普通情况下钥 匙的使用原则吗。现在不是普通情况了。你所取得的那把钥匙不是永远不还,而是在退出同步代码块时才还。           还用前面那个想连续用两个上锁房间的家伙打比方。怎样才能在用完一间以后,继续使用另一间呢。用同步代码块吧。先创建另外 一个线程,做一个同步代码 块,把那个代码块的锁指向这个房子的钥匙。然后启动那个线程。只要你能在进入那个代码块时抓到这房子的钥匙 ,你就可以一直保留到退出那个代码块。也就是说 你甚至可以对本房内所有上锁的房间遍历,甚至再sleep(10601000),而房门口却还有 1000个线程在等这把钥匙呢。很过瘾吧。           在此对sleep()方法和钥匙的关联性讲一下。一个线程在拿到key后,且没有完成同步的内容时,如果被强制sleep()了,那key还一 直在 它那儿。直到它再次运行,做完所有同步内容,才会归还key。记住,那家伙只是干活干累了,去休息一下,他并没干完他要干的事。为 了避免别人进入那个房间 把里面搞的一团糟,即使在睡觉的时候他也要把那唯一的钥匙戴在身上。           最后,也许有人会问,为什么要一把钥匙通开,而不是一个钥匙一个门呢?我想这纯粹是因为复杂性问题。一个钥匙一个门当然更 安全,但是会牵扯好多问题。钥匙 的产生,保管,获得,归还等等。其复杂性有可能随同步方法的增加呈几何级数增加,严重影响效率。这也 算是一个权衡的问题吧。为了增加一点点安全性,导致效 率大大降低,是多么不可取啊。 synchronized的一个简单例子 public class TextThread { public static void main(String[] args) {    TxtThread tt = new TxtThread();    new Thread(tt).start();    new Thread(tt).start();    new Thread(tt).start();    new Thread(tt).start(); } } class TxtThread implements Runnable { int num = 100; String str = new String(); public void run() {    synchronized (str) {     while (num > 0) {      try {       Thread.sleep(1);      } catch (Exception e) {       e.getMessage();      }      System.out.println(Thread.currentThread().getName()        + "this is " + num--);     }    } } } 上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10) Java对多线程的支持与同步机制深受大家的喜爱,似乎看起来使用了synchronized关键字就可以轻松地解决多线程共享数据同步问题。到底如 何?――还得对synchronized关键字的作用进行深入了解才可定论。 总的说来,synchronized关键字可以作为函数的修饰符,也可作为函数内的语句,也就是平时说的同步方法和同步语句块。如果再细的分类, synchronized可作用于instance变量、object reference(对象引用)、static函数和class literals(类名称字面常量)身上。 在进一步阐述之前,我们需要明确几点: A.无论synchronized关键字加在方法上还是对象上,它取得的锁都是对象,而不是把一段代码或函数当作锁――而且同步方法很可能还会被其 他线程的对象访问。 B.每个对象只有一个锁(lock)与之相关联。 C.实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制。 接着来讨论synchronized用到不同地方对代码产生的影响: 假设P1、P2是同一个类的不同对象,这个类中定义了以下几种情况的同步块或同步方法,P1、P2就都可以调用它们。 1. 把synchronized当作函数修饰符时,示例代码如下: Public synchronized void methodAAA() { //…. } 这也就是同步方法,那这时synchronized锁定的是哪个对象呢?它锁定的是调用这个同步方法对象。也就是说,当一个对象P1在不同的线程中 执行这个同步方法时,它们之间会形成互斥,达到同步的效果。但是这个对象所属的Class所产生的另一对象P2却可以任意调用这个被加了 synchronized关键字的方法。 上边的示例代码等同于如下代码: public void methodAAA() { synchronized (this)      // (1) {        //….. } } (1)处的this指的是什么呢?它指的就是调用这个方法的对象,如P1。可见同步方法实质是将synchronized作用于object reference。――那个 拿到了P1对象锁的线程,才可以调用P1的同步方法,而对P2而言,P1这个锁与它毫不相干,程序也可能在这种情形下摆脱同步机制的控制,造 成数据混乱:( 2.同步块,示例代码如下: public void method3(SomeObject so) {     synchronized(so)     {        //…..     } } 这时,锁就是so这个对象,谁拿到这个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时,就可以这样写程序,但当没有明 确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的instance变量(它得是一个对象)来充当锁: class Foo implements Runnable {         private byte[] lock = new byte[0]; // 特殊的instance变量         Public void methodA()         {            synchronized(lock) { //… }         }         //….. } 注:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:生成零长度的byte[]对象只需3条操作码,而Object lock = new Object()则需要7行操作码。 3.将synchronized作用于static 函数,示例代码如下: Class Foo {     public synchronized static void methodAAA()   // 同步的static 函数     {         //….     }     public void methodBBB()     {        synchronized(Foo.class)   // class literal(类名称字面常量)     } }    代码中的methodBBB()方法是把class literal作为锁的情况,它和同步的static函数产生的效果是一样的,取得的锁很特别,是当前调用这 个方法的对象所属的类(Class,而不再是由这个Class产生的某个具体对象了)。 记得在《Effective Java》一书中看到过将 Foo.class和 P1.getClass()用于作同步锁还不一样,不能用P1.getClass()来达到锁这个Class的 目的。P1指的是由Foo类产生的对象。 可以推断:如果一个类中定义了一个synchronized的static函数A,也定义了一个synchronized 的instance函数B,那么这个类的同一对象Obj 在多线程中分别访问A和B两个方法时,不会构成同步,因为它们的锁都不一样。A方法的锁是Obj这个对象,而B的锁是Obj所属的那个Class。 小结如下: 搞清楚synchronized锁定的是哪个对象,就能帮助我们设计更安全的多线程程序。 还有一些技巧可以让我们对共享资源的同步访问更加安全: 1. 定义private 的instance变量+它的 get方法,而不要定义public/protected的instance变量。如果将变量定义为public,对象在外界可以 绕过同步方法的控制而直接取得它,并改动它。这也是JavaBean的标准实现方式之一。 2. 如果instance变量是一个对象,如数组或ArrayList什么的,那上述方法仍然不安全,因为当外界对象通过get方法拿到这个instance对象 的引用后,又将其指向另一个对象,那么这个private变量也就变了,岂不是很危险。 这个时候就需要将get方法也加上synchronized同步,并 且,只返回这个private对象的clone()――这样,调用端得到的就是对象副本的引用了 作者:hanwei_java 来源:CSDN 原文:https://blog.csdn.net/hanwei_java/article/details/79738614 版权声明:本文为博主原创文章,转载请附上博文链接!

auto_answer 2019-12-02 01:50:26 0 浏览量 回答数 0

回答

一.什么是sychronizedsychronized是java中最基本同步互斥的手段,可以修饰代码块,方法,类.在修饰代码块的时候需要一个reference对象作为锁的对象.在修饰方法的时候默认是当前对象作为锁的对象.在修饰类时候默认是当前类的Class对象作为锁的对象.synchronized会在进入同步块的前后分别形成monitorenter和monitorexit字节码指令.在执行monitorenter指令时会尝试获取对象的锁,如果此没对象没有被锁,或者此对象已经被当前线程锁住,那么锁的计数器加一,每当monitorexit被锁的对象的计数器减一.直到为0就释放该对象的锁.由此synchronized是可重入的,不会出现自己把自己锁死.二.什么ReentrantLock以对象的方式来操作对象锁.相对于sychronized需要在finally中去释放锁 三.synchronized和ReentrantLock的区别除了synchronized的功能,多了三个高级功能.等待可中断,公平锁,绑定多个Condition.1.等待可中断在持有锁的线程长时间不释放锁的时候,等待的线程可以选择放弃等待. tryLock(long timeout, TimeUnit unit)2.公平锁按照申请锁的顺序来一次获得锁称为公平锁.synchronized的是非公平锁,ReentrantLock可以通过构造函数实现公平锁. new RenentrantLock(boolean fair)3.绑定多个Condition通过多次newCondition可以获得多个Condition对象,可以简单的实现比较复杂的线程同步的功能.通过await(),signal();

蛮大人123 2019-12-02 01:56:53 0 浏览量 回答数 0

问题

【精品问答】Java专业术语50问

游客pklijor6gytpx 2019-12-01 21:56:07 13032 浏览量 回答数 4

回答

C. synchronized synchronized:在需要同步的对象中加入此控制,synchronized可以加在方法上,也可以加在特定代码块中,括号中表示需要锁的对象 Java为此也提供了另一个锁机制Lock

游客in6prsll3yfsc 2020-04-17 18:28:17 0 浏览量 回答数 0

回答

C. synchronized synchronized:在需要同步的对象中加入此控制,synchronized可以加在方法上,也可以加在特定代码块中,括号中表示需要锁的对象 Java为此也提供了另一个锁机制Lock

1366772604586924 2020-04-16 10:05:40 0 浏览量 回答数 0

回答

问题很好。Java的多线程编程是很重要的知识点。Java程序员可以看看《Java并发编程的艺术》相关的书籍,目前对于大部分Java程序员来说,做好多线程编程,最好是依赖底层的框架。相对来说出问题的概率比较低,而且容易实现。如果非常熟练,可以参考编写一些多线程的代码。Java多线程目前封装比较好的框架是JUC库。可以直接使用。多线程,如果数据都是隔离,每个线程单独所有,不会出现线程安全问题,相对简单。但是如果涉及到共享问题,就比较麻烦。涉及线程安全必然有锁的问题,Lock和Synchronized关键字的使用。共享资源加锁,一般说为悲观锁,必然会导致其他线程等待,尽快处理,及时释放是最好的策略。如果是乐观锁,并发问题相对处理简单,但是无法保证数据一致性。Lock接口允许自己实现共享资源的锁定和释放,效率高,编码工作量大。Synchronized相对简单,关键字,但是性能不如Lock.你提到的CAS也是CPU低等的指令。效率比较高。如果可以尽量使用现有的Java多线程框架,可以降低底层的编码实现难度,线程调度和锁机制太复杂。积累一定经验,或者项目实在需要,标准框架无法满足的时候,可以尝试优化,或者自己实现多线程代码。

徐雷frank 2019-12-02 01:45:57 0 浏览量 回答数 0

回答

1)HashTable是线程安全的,其提供的public方法上都加了synchronized关键字,效率是比较低的;2)HashMap是非线程安全的,多线程操作会导致并发冲突异常,单线程场景高效;3)ConcurrentHashMap是线程安全的,与HashTable的实现机制不同,并没有通过加synchronized关键字的方式实现同步锁,在java8之前它是通过分段(segment)锁的方式来实现的,降低并发冲突,但是在java8中实现方式上有所调整,采取按行加锁,进一步降低并发冲突概率,具体可以参考jdk8源码实现

talishboy 2019-12-02 01:46:43 0 浏览量 回答数 0

回答

java在过去很长一段时间只能通过synchronized关键字来实现互斥,它有一些缺点。比如你不能扩展锁之外的方法或者块边界,尝试获取锁时不能中途取消等。Java 5 通过Lock接口提供了更复杂的控制来解决这些问题。 ReentrantLock 类实现了 Lock,它拥有与 synchronized 相同的并发性和内存语义且它还具有可扩展性。

游客bnlxddh3fwntw 2020-04-10 13:59:27 0 浏览量 回答数 0

问题

java Synchronized 内存可见性问题:报错

kun坤 2020-06-07 12:19:52 0 浏览量 回答数 1

问题

java 多线程读一个变量需要加锁吗

蛮大人123 2019-12-01 20:06:59 1085 浏览量 回答数 1

回答

乐观锁:其实都是一种概念,乐观锁认为并发的时候,不会有很多次修改数据操作,所以读取数据不用加锁,真正修改了就回滚读操作。乐观锁在Java里面有一种cas实现 悲观锁:和乐观锁相反,认为修改会随时发生,任何时候都需要锁定数据。这个java采用Synchronized实现。

问问小秘 2020-02-17 11:33:44 0 浏览量 回答数 0

回答

线程3可以看到最新值,java会对锁住的对象判断是否处于竞争中,如果没有被竞争,那么会立即执行。如果三个线程是并发执行,那种情况就不确定了,线程2都不一定是最新值,因为有可能线程1还未执行。 如果线程1先执行,那么lock1就已经被释放了,那么此时lock1和lock2就都是处于未被锁住的情况,即不存在锁竞争关系,线程2 、3同时执行必然能取到最新值,不然java的多线程会出现不可预估的数据错误,后果很严重。 锁的意义是防止线程竞争造成共享数据混乱,有竞争就会让线程排队等候,其实就是把同时执行的情况改造成类似同步的顺序执行,Synchronized这个词的意思就是“同步”,其本质就是让线程的异步变为同步 ######回复 @疯狂的骑士 : 是锁未处于竞争状态其内的共享变量应该是最新的######按你的说法, synchronized代码块内,所有的共享变量都是最新值,不管是不是同一个锁,synchronized的语义可以理解为刷新主存的变量值到当前线程的缓存中? 最近的项目涉及这个问题,我加了synchronized,但是变量值没更新,找不到哪出错了,后面把变量声明为volatile,才解决问题。###### 描述里只是说明synchronized开始时刷新一次和退出时提交一次,但并不表示代码块在执行的过程中,不会提交或刷新共享变量,所以情况分很多种,纠结这种问题没什么意义. 你可以在set()方法里写一个循环对num进行累加,在get2()里多次获取,看看锁未释放时,num是不是不变的. ######这个问题可是很重要的,而且这种问题很难测试

kun坤 2020-06-07 12:19:58 0 浏览量 回答数 0

回答

Java多线程的wait()方法和notify()方法这两个方法是成对出现和使用的,要执行这两个方法,有一个前提就是,当前线程必须获其对象的monitor(俗称“锁”),否则会抛出IllegalMonitorStateException异常,所以这两个方法必须在同步块代码里面调用。wait():阻塞当前线程notify():唤起被wait()阻塞的线程不可重入锁所谓不可重入锁,即若当前线程执行某个方法已经获取了该锁,那么在方法中尝试再次获取锁时,就会获取不到被阻塞。我们尝试设计一个不可重入锁:public class Lock{private boolean isLocked = false; public synchronized void lock() throws InterruptedException{ while(isLocked){ wait(); } isLocked = true; } public synchronized void unlock(){ isLocked = false; notify(); }}使用该锁:public class Count{Lock lock = new Lock(); public void print(){ lock.lock(); doAdd(); lock.unlock(); } public void doAdd(){ lock.lock(); //do something lock.unlock(); }}当前线程执行print()方法首先获取lock,接下来执行doAdd()方法就无法执行doAdd()中的逻辑,必须先释放锁。这个例子很好的说明了不可重入锁。可重入锁接下来,我们设计一种可重入锁public class Lock{boolean isLocked = false; Thread lockedBy = null; int lockedCount = 0; public synchronized void lock() throws InterruptedException{ Thread thread = Thread.currentThread(); while(isLocked && lockedBy != thread){ wait(); } isLocked = true; lockedCount++; lockedBy = thread; } public synchronized void unlock(){ if(Thread.currentThread() == this.lockedBy){ lockedCount--; if(lockedCount == 0){ isLocked = false; notify(); } } }}所谓可重入,意味着线程可以进入它已经拥有的锁的同步代码块儿。我们设计两个线程调用print()方法,第一个线程调用print()方法获取锁,进入lock()方法,由于初始lockedBy是null,所以不会进入while而挂起当前线程,而是是增量lockedCount并记录lockBy为第一个线程。接着第一个线程进入doAdd()方法,由于同一进程,所以不会进入while而挂起,接着增量lockedCount,当第二个线程尝试lock,由于isLocked=true,所以他不会获取该锁,直到第一个线程调用两次unlock()将lockCount递减为0,才将标记为isLocked设置为false。可重入锁的概念和设计思想大体如此,Java中的可重入锁ReentrantLock设计思路也是这样作者:Androider_Zxg 来源:CSDN 原文:https://blog.csdn.net/u012545728/article/details/80843595 版权声明:本文为博主原创文章,转载请附上博文链接!

孟志昂 2019-12-02 01:45:18 0 浏览量 回答数 0

回答

何谓悲观锁与乐观锁乐观锁对应于生活中乐观的人总是想着事情往好的方向发展,悲观锁对应于生活中悲观的人总是想着事情往坏的方向发展。这两种人各有优缺点,不能不以场景而定说一种人好于另外一种人。悲观锁总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程)。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。乐观锁总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

huanhuanming 2019-12-02 01:50:31 0 浏览量 回答数 0

回答

Java中可以使用synchronized关键保证线程安全,也可以使用jdk提供的Lock锁,或者使用cas乐观锁来实现线程安全

有头发的程序猿 2019-12-02 03:13:20 0 浏览量 回答数 0

回答

加事物,会加锁######查询语句加一个for update###### 加个全局锁就行了,这个锁未释放时就算其它线程再次访问这个方法,那也得排队等待锁的释放。######怎么加全局锁 能说详细点吗 谢谢###### 我咋感觉他的意思是要单例模式###### 数据库加锁######具体怎么加呢###### public void synchronize method() { }######另外注意开启 JDBC 事务设置事务级别 8 Serializable######只是为了防止这个方法被重复调用,那就单例模式吧。防止其他方法也更改这条数据,那就数据层加锁######数据层 加锁的话 怎么加 能说说大概吗###### private static final String lock = "lock"; public void process(String id) { synchronized(lock) { ... } } 类似这样就行了,synchronized是java提供的古老而重量级锁实现,你也可以使用jdk7或者是jdk8中优化的锁实现,更加轻量。 当然你也可以给数据库加行锁,mysql InnoDB加行锁类似 select * from table where id = 1 for update;######回复 @开源中国技术顾问 : 抱歉!我只注意到“其它线程调用此方法”。如果还有其它代码有可能改变那你就用数据库锁实现吧。######这种加锁 只能保证这里面的安全 要是其他地方也可能更改查询后的值呢 如何保证其他地方######这种加锁方式和 synchronized (类.class)应该是一个道理吗 都是对类的加锁吧######mysql InnoDB行锁有其限制条件,请认真查阅资料后考虑是否使用,再者还得考虑代码层加锁和数据层加锁哪种方式更加可靠。

kun坤 2020-06-06 11:32:36 0 浏览量 回答数 0

回答

Java 中每一个对象都可以作为锁,这是 synchronized 实现同步的基础:普通同步方法,锁是当前实例对象。静态同步方法,锁是当前类的class对象。同步方法块,锁是括号里面的对象。每个对象有一个监视器锁。对于同步代码块,monitorenter 指令插入到同步代码块的开始位置,monitorexit 指令插入到同步代码块的结束位置。对于 monitorenter,如果 monitor 的进入数为 0,则该线程进入 monitor,然后将进入数设置为 1,该线程即为 monitor 的所有者。如果线程已经占有该 monitor,只是重新进入,则进入 monitor 的进入数加 1。如果其他线程已经占用了 monitor,则该线程进入阻塞状态,直到 monitor 的进入数为 0,再重新尝试获取 monitor 的所有权。对于 monitorexit,指令执行时,monitor 的进入数减 1,如果减 1 后进入数为 0,那线程退出 monitor,不再是这个 monitor 的所有者。对于 synchronized 方法,会被翻译成普通的方法,JVM 根据 ACC_SYNCHRONIZED 标示符来实现方法的同步。当方法调用时,调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程将先获取 monitor,获取成功之后才能执行方法体,方法执行完后再释放 monitor。在方法执行期间,其他任何线程都无法再获得同一个 monitor 对象。

景凌凯 2020-04-22 17:08:13 0 浏览量 回答数 0

问题

java内置锁的问题

蛮大人123 2019-12-01 20:17:26 704 浏览量 回答数 1

回答

悲观锁 总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程)。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。 乐观锁 总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

游客duzwdtzqsaq3i 2020-08-03 21:24:56 0 浏览量 回答数 0

问题

java 线程安全问题:报错

kun坤 2020-06-09 23:07:33 0 浏览量 回答数 1

回答

首先,Java web请求处理是多线程的,即每个请求都是由一个线程来处理的,多用户同时访问同一个请求时,也是在各自线程中的,如果线程同步使用的锁用synchronized同步非静态方法的话,那么锁监视器就是当前对象this。你说的多个用户同时取钱,各自用自己的锁对象的话,应该不能相互影响的吧。

蛮大人123 2019-12-02 02:32:48 0 浏览量 回答数 0

回答

在并发编程中,我们通常会遇到以下三个问题:原子性问题,可见性问题,有序性问题。volatile关键字的作用是解决可见性问题的,但不能保证原子性,如果要保证原子性,还需要使用锁(synchronized,Lock,CAS)。synchronized关键字是防止多个线程同时执行一段代码,那么就会很影响程序执行效率,而volatile关键字在某些情况下性能要优于synchronized,下面列举几个Java中使用volatile的几个场景。1.状态标记量volatile boolean flag = false; while(!flag){ doSomething(); } public void setFlag() { flag = true; }volatile boolean inited = false; //线程1: context = loadContext(); inited = true; //线程2: while(!inited ){ sleep() } doSomethingwithconfig(context);2.double checkclass Singleton{ private volatile static Singleton instance = null; private Singleton() { } public static Singleton getInstance() { if(instance==null) { synchronized (Singleton.class) { if(instance==null) instance = new Singleton(); } } return instance; } }

存信 2019-12-02 01:57:28 0 浏览量 回答数 0

回答

不行,同步使用的是锁机制,实例方法头部加关键字synchronized默认其锁是this对象,所以当一个对象执行get时,另一个线程对这个对象(同前一个线程中的对象)也不能执行set。你想线程安全,是不可能达到你想要的效果的,但是读写锁分离锁可以达到多个线程可以同时进入get方法,读写锁在java中的代码如下: private static final ReentrantReadWriteLock reentrantLock = new ReentrantReadWriteLock(true); private static final ReadLock readLock = reentrantLock.readLock(); private static final WriteLock writeLock = reentrantLock.writeLock();

蛮大人123 2019-12-02 02:06:59 0 浏览量 回答数 0

回答

因为你的java里用的是double check方式,加上用synchronized对类实例方法加锁,当一开始有多个线程同时要该实例时,就会出现只有一个线程能进入类实现方法,其他线程等待解锁,当第一条线程将类实例后,其他线程进入加锁块时,就会被第二个判断拒绝而会获取已实例的实例;而php中没有对类实现方法加锁。

小旋风柴进 2019-12-02 02:01:37 0 浏览量 回答数 0

回答

sleep()方法  sleep()使当前线程进入停滞状态(阻塞当前线程),让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给其他线程执行的机会;   sleep()是Thread类的Static(静态)的方法;因此他不能改变对象的机锁,所以当在一个Synchronized块中调用Sleep()方法是,线程虽然休眠了,但是对象的机锁并木有被释放,其他线程无法访问这个对象(即使睡着也持有对象锁)。  在sleep()休眠时间期满后,该线程不一定会立即执行,这是因为其它线程可能正在运行而且没有被调度为放弃执行,除非此线程具有更高的优先级。    wait()方法  wait()方法是Object类里的方法;当一个线程执行到wait()方法时,它就进入到一个和该对象相关的等待池中,同时失去(释放)了对象的机锁(暂时失去机锁,wait(long timeout)超时时间到后还需要返还对象锁);其他线程可以访问;  wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。  wiat()必须放在synchronized block中,否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。所以sleep()和wait()方法的最大区别是: sleep()睡眠时,保持对象锁,仍然占有该锁; 而wait()睡眠时,释放对象锁。 但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态,从而使线程立刻抛出InterruptedException(但不建议使用该方法)。

helluo 2019-12-02 02:18:18 0 浏览量 回答数 0

回答

1 java中==和equals和hashCode的区别是什么? 2 int与integer的区别是什么? 3 String、StringBuffer、StringBuilder区别是什么? 4 什么是内部类?内部类的作用是什么? 5 进程和线程的区别是什么? 6 final,finally,finalize的区别是什么? 7 Serializable 和Parcelable 的区别是什么? 8 静态属性和静态方法是否可以被继承?是否可以被重写?以及原因? 9 成员内部类、静态内部类、局部内部类和匿名内部类的理解,以及项目中的应用是什么 10 string 转换成 integer的方式及原理是什么? 11 哪些情况下的对象会被垃圾回收机制处理掉? 12 静态代理和动态代理的区别,什么场景使用? 13 Java中实现多态的机制是什么? 14 说说你对Java反射的理解 15 说说你对Java注解的理 16 Java中String的了解 17 String为什么要设计成不可变的? 18 Object类的equal和hashCode方法重写,为什么? 19 List,Set,Map的区别是什么? 20 ArrayMap和HashMap的对比是什么? 21 HashMap和HashTable的区别是什么? 22 HashMap与HashSet的区别是什么? 23 HashSet与HashMap怎么判断集合元素重复? 24 ArrayList和LinkedList的区别,以及应用场景是什么? 25 数组和链表的区别是什么? 26 开启线程的三种方式是什么? 27 线程和进程的区别是什么? 28 如何控制某个方法允许并发访问线程的个数? 29 run()和start()方法区别是什么? 30 在Java中wait和seelp方法的不同; 31 什么导致线程阻塞?线程如何关闭? 32 如何保证线程安全? 33 如何实现线程同步? 34 线程间操作List 35 谈谈对Synchronized关键字,类锁,方法锁,重入锁的理解 36 synchronized 和volatile 关键字的区别是什么? 37 ReentrantLock 、synchronized和volatile比较 38 死锁的四个必要条件? 39 什么是线程池,如何使用? 40 Java中堆和栈有什么不同? 41 有三个线程T1,T2,T3,怎么确保它们按顺序执行? 42 AsyncTask的工作原理是什么? 43 Binder的工作机制是什么?

剑曼红尘 2020-04-10 14:32:30 0 浏览量 回答数 0

回答

死锁是这样一种情形:多个线程同时被阻塞,它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞,因此程序不可能正常终止。 java 死锁产生的四个必要条件: 1、互斥使用,即当资源被一个线程使用(占有)时,别的线程不能使用 2、不可抢占,资源请求者不能强制从资源占有者手中夺取资源,资源只能由资源占有者主动释放。 3、请求和保持,即当资源请求者在请求其他的资源的同时保持对原有资源的占有。 4、循环等待,即存在一个等待队列:P1占有P2的资源,P2占有P3的资源,P3占有P1的资源。这样就形成了一个等待环路。 当上述四个条件都成立的时候,便形成死锁。当然,死锁的情况下如果打破上述任何一个条件,便可让死锁消失。下面用java代码来模拟一下死锁的产生。 解决死锁问题的方法是:一种是用synchronized,一种是用Lock显式锁实现。 而如果不恰当的使用了锁,且出现同时要锁多个对象时,会出现死锁情况,如下: LockTest.java 文件 import java.util.Date; public class LockTest { public static String obj1 = "obj1"; public static String obj2 = "obj2"; public static void main(String[] args) { LockA la = new LockA(); new Thread(la).start(); LockB lb = new LockB(); new Thread(lb).start(); } } class LockA implements Runnable{ public void run() { try { System.out.println(new Date().toString() + " LockA 开始执行"); while(true){ synchronized (LockTest.obj1) { System.out.println(new Date().toString() + " LockA 锁住 obj1"); Thread.sleep(3000); // 此处等待是给B能锁住机会 synchronized (LockTest.obj2) { System.out.println(new Date().toString() + " LockA 锁住 obj2"); Thread.sleep(60 * 1000); // 为测试,占用了就不放 } } } } catch (Exception e) { e.printStackTrace(); } } } class LockB implements Runnable{ public void run() { try { System.out.println(new Date().toString() + " LockB 开始执行"); while(true){ synchronized (LockTest.obj2) { System.out.println(new Date().toString() + " LockB 锁住 obj2"); Thread.sleep(3000); // 此处等待是给A能锁住机会 synchronized (LockTest.obj1) { System.out.println(new Date().toString() + " LockB 锁住 obj1"); Thread.sleep(60 * 1000); // 为测试,占用了就不放 } } } } catch (Exception e) { e.printStackTrace(); } } } 以上代码运行输出结果为: Tue May 05 10:51:06 CST 2015 LockB 开始执行 Tue May 05 10:51:06 CST 2015 LockA 开始执行 Tue May 05 10:51:06 CST 2015 LockB 锁住 obj2 Tue May 05 10:51:06 CST 2015 LockA 锁住 obj1 此时死锁产生。 为了解决这个问题,我们不使用显示的去锁,我们用信号量去控制。 信号量可以控制资源能被多少线程访问,这里我们指定只能被一个线程访问,就做到了类似锁住。而信号量可以指定去获取的超时时间,我们可以根据这个超时时间,去做一个额外处理。 对于无法成功获取的情况,一般就是重复尝试,或指定尝试的次数,也可以马上退出。 来看下如下代码: UnLockTest.java 文件 import java.util.Date; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; public class UnLockTest { public static String obj1 = "obj1"; public static final Semaphore a1 = new Semaphore(1); public static String obj2 = "obj2"; public static final Semaphore a2 = new Semaphore(1); public static void main(String[] args) { LockAa la = new LockAa(); new Thread(la).start(); LockBb lb = new LockBb(); new Thread(lb).start(); } } class LockAa implements Runnable { public void run() { try { System.out.println(new Date().toString() + " LockA 开始执行"); while (true) { if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + " LockA 锁住 obj1"); if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + " LockA 锁住 obj2"); Thread.sleep(60 * 1000); // do something }else{ System.out.println(new Date().toString() + "LockA 锁 obj2 失败"); } }else{ System.out.println(new Date().toString() + "LockA 锁 obj1 失败"); } UnLockTest.a1.release(); // 释放 UnLockTest.a2.release(); Thread.sleep(1000); // 马上进行尝试,现实情况下do something是不确定的 } } catch (Exception e) { e.printStackTrace(); } } } class LockBb implements Runnable { public void run() { try { System.out.println(new Date().toString() + " LockB 开始执行"); while (true) { if (UnLockTest.a2.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + " LockB 锁住 obj2"); if (UnLockTest.a1.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + " LockB 锁住 obj1"); Thread.sleep(60 * 1000); // do something }else{ System.out.println(new Date().toString() + "LockB 锁 obj1 失败"); } }else{ System.out.println(new Date().toString() + "LockB 锁 obj2 失败"); } UnLockTest.a1.release(); // 释放 UnLockTest.a2.release(); Thread.sleep(10 * 1000); // 这里只是为了演示,所以tryAcquire只用1秒,而且B要给A让出能执行的时间,否则两个永远是死锁 } } catch (Exception e) { e.printStackTrace(); } } } 以上实例代码输出结构为: Tue May 05 10:59:13 CST 2015 LockA 开始执行 Tue May 05 10:59:13 CST 2015 LockB 开始执行 Tue May 05 10:59:13 CST 2015 LockB 锁住 obj2 Tue May 05 10:59:13 CST 2015 LockA 锁住 obj1 Tue May 05 10:59:14 CST 2015LockB 锁 obj1 失败 Tue May 05 10:59:14 CST 2015LockA 锁 obj2 失败 Tue May 05 10:59:15 CST 2015 LockA 锁住 obj1 Tue May 05 10:59:15 CST 2015 LockA 锁住 obj2

问问小秘 2020-02-13 17:54:01 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站