synchronized

Synchronized关键字算是Java的元老级锁了，一开始它撑起了Java的同步任务，其用法简单粗暴容易上手。但是有些与它相关的知识点还是需要我们开发者去深入掌握的。比如，我们都知道通过Synchronized锁来实现互斥功能，可以用在方法或者代码块上，那么不同用法都是怎么实现的,以及都经历了了哪些优化等等问题都需要我们扎实的理解。 1.基本用法 2.实现原理 2.1 同步代码块的实现 2.2 同步方法的实现 3.锁升级 3.1 Java对象头介绍 3.2 什么是锁升级 1.基本用法 通常我们可以把Synchronized用在一个方法或者代码块里，方法又有普通方法或者静态方法。 对于普通同步方法，锁是当前实例对象，也就是this public class TestSyn{ private int i=0; public synchronized void incr(){ i++; } } 对于静态同步方法，锁是Class对象 public class TestSyn{ private static int i=0; public static synchronized void incr(){ i++; } } 对于同步代码块，锁是同步代码块里的对象 public class TestSyn{ private int i=0; Object o = new Object();

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 由 翻译 强力驱动 问题: A warning is showing every time I synchronize on a non-final class field. Here is the code: public class X { private Object o ; public void setO ( Object o ) { this . o = o ; } public void x () { synchronized ( o ) // synchronization on a non-final field { } } } so i changed the coding in the following way.. public class X { private final Object o ; public X () { o = new Object (); } public void x () { synchronized ( o ) { } } } I am not sure the above code is the proper way to synchronize on a non-final class field. How can I

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: If I have a util class with static methods that will call Hibernate functions to accomplish basic data access. I am wondering if making the method synchronized is the right approach to ensure thread-safety. I want this to prevent access of info to the same DB instance. However, I'm now sure if the following code are preventing getObjectById being called for all Classes when it is called by a particular class. public class Utils { public static synchronized Object getObjectById (Class objclass, Long id) { // call hibernate class Session

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: MySQL has a handy function: SELECT GET_LOCK("SomeName") This can be used to create simple, but very specific, name based locks for an application. However, it requires a database connection. I have many situations like: someMethod() { // do stuff to user A for their data for feature X } It doesn't make sense to simply synchronize this method, because, for example, if this method is called for user B in the meantime, user B does not need to wait for user A to finish before it starts, only operations for the user A and feature X combination

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: Vector is synchronized, ArrayList is not synchronized but we can synchronize an ArrayList by Collections.synchronizedList(aList) , so which will perform better and faster? 回答1: Synchronized collections are a waste of time and dangerous. A trivial example why they are bad is to consider two threads running a loop at the same time on the same collection: int i = 0; while (i Our list could be synchronized (e.g. a Vector) and this code would still break horribly. Why? Because the individual calls to size(), get(), remove(), are synchronized but

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: I'm trying to create a basic following algorithm using Swift and Firebase. My current implementation is the following: static func follow(user: FIRUser, userToFollow: FIRUser) { database.child("users").child(user.uid).observeSingleEventOfType(.Value, withBlock: { (snapshot) in var dbFollowing: NSMutableArray! = snapshot.value!["Following"] as! NSMutableArray! dbFollowing?.addObject(userToFollow.uid) self.database.child("users/"+(user.uid)+"/").updateChildValues(["Following":dbFollowing!]) //add user uid to userToFollows followers array in

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: By design, std::mutex is not movable nor copy-constructable. This means that a class A , which holds a mutex, won't receive a default-move-constructor. How would I make this type A movable in a thread-safe way? 回答1: Let's start with a bit of code: class A { using MutexType = std::mutex; using ReadLock = std::unique_lock ; using WriteLock = std::unique_lock ; mutable MutexType mut_; std::string field1_; std::string field2_; public: ... I've put some rather suggestive type aliases in there that we won't really take advantage of in C++11, but

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: I am trying to run the following code in android URLConnection l_connection = null; // Create connection uzip=new UnZipData(mContext); l_url = new URL(serverurl); if ("https".equals(l_url.getProtocol())) { System.out.println(">>>>>>>>>>>"); sslcontext = SSLContext.getInstance("TLS"); System.out.println(">>>>>>>>>>>"); sslcontext.init(null, new TrustManager[] { new CustomTrustManager()}, new java.security.SecureRandom()); HttpsURLConnection .setDefaultHostnameVerifier(new CustomHostnameVerifier()); HttpsURLConnection

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: I am attempting to use synchronize method in spring controller. Because our Payment gateway hits method [@RequestMapping(value="/pay",method=RequestMethod.POST)] different transactions [txn id : txn01 & txn02] at a time. But these 2 different transaction processing one by one than parallel due to using synchronize block. Problem -> Why i am using synchronize block in controller is that say Transaction [txn01] hits [@RequestMapping(value="/pay",method=RequestMethod.POST)] twice like duplicate call from payment gateway. before finishing first

可以将文章内容翻译成中文,广告屏蔽插件可能会导致该功能失效(如失效，请关闭广告屏蔽插件后再试): 问题: I'm trying to create an app that makes HTTP requests through an intentservice. I need the app to wait for the service to finish its run (aka, have the request be returned with some data) before it continues its operations, as its operations involve manipulation of the data I hope to receive from the HTTP requests. I've tried numerous means of doing so - Semaphore, CountDownLatch, but it seems that for all of them, I need some method of passing in the waiting/counting object into the intentservice so that it can tell the main thread where