线程同步和单例问题
Thread synch and singleton questions
首先我需要清除一些基本的东西,假设我有一个同步块或一个同步方法并且一个线程已经进入同步部分并且有 5 个新线程尝试访问同步部分,它们会停止吗运行 直到第一个线程离开同步部分?如果他们这样做,他们会在优先队列中等待吗?
第二个问题是关于监视器的,假设我有以下代码:
synchronized(someObject){
//do some stuff
someObject.wait();
}
假设如果一个线程运行此代码而另一个线程正在等待监视器然后第一个线程调用等待,第二个线程将进入代码块(即等待释放 someObject
的监视器)是否正确? ?
最后一个问题是关于 Singleton 实现的,为了使其线程安全,是否足以同步 Singleton 中的实例化行 class 以确保它永远不会被调用超过一次?如果是这样,这是最佳做法吗?
First off I need to clear something basic, assume I have a synchronized block or a synchronized method and one thread already entered the synchronized part and 5 new threads try to access the synchronized part, will they stop running until the first thread leaves the synchronized part? and if they do, will they wait in a prioritized queue?
如果一个线程在监视器上拥有锁,则其他线程无法在同一对象上获取相同的锁。因此,他们会阻止。一旦当前线程放弃了它的锁,另一个线程就可以获取锁。在优先级方面,即使一个线程的优先级高于另一个线程,也不能保证优先级较高的线程会 运行 优先于优先级较低的线程。
ReentrantLock class 构造函数提供了创建公平锁或非公平锁的可能性。在公平场景中,线程按照它们请求它的顺序获取对象上的锁。在不公平的情况下,允许插入请求,其中一个请求可能会插入请求队列中更高的位置。
Second question is regarding monitors, assume I have a the following code:
synchronized(someObject){
//do some stuff
someObject.wait();
}
Is it correct to assume that if a thread runs this code while another thread is waiting on the monitor and then the first thread calls wait, the second thread will enter the code block (I.E. the wait releases someObject's monitor) ?
当前线程调用wait时,当前线程会释放对该对象的所有锁。一旦该锁被释放,其他线程可能会尝试获取同一对象上的同一锁。
And last question is regarding a Singleton implementation, in order to make it thread safe is it enough to synchronize the instantiation line inside the singleton class to make sure it never gets called more than once ? and if so, is this the best practice ?
参见 this post 关于线程安全单例 classes.
首先我需要清除一些基本的东西,假设我有一个同步块或一个同步方法并且一个线程已经进入同步部分并且有 5 个新线程尝试访问同步部分,它们会停止吗运行 直到第一个线程离开同步部分?如果他们这样做,他们会在优先队列中等待吗?
第二个问题是关于监视器的,假设我有以下代码:
synchronized(someObject){
//do some stuff
someObject.wait();
}
假设如果一个线程运行此代码而另一个线程正在等待监视器然后第一个线程调用等待,第二个线程将进入代码块(即等待释放 someObject
的监视器)是否正确? ?
最后一个问题是关于 Singleton 实现的,为了使其线程安全,是否足以同步 Singleton 中的实例化行 class 以确保它永远不会被调用超过一次?如果是这样,这是最佳做法吗?
First off I need to clear something basic, assume I have a synchronized block or a synchronized method and one thread already entered the synchronized part and 5 new threads try to access the synchronized part, will they stop running until the first thread leaves the synchronized part? and if they do, will they wait in a prioritized queue?
如果一个线程在监视器上拥有锁,则其他线程无法在同一对象上获取相同的锁。因此,他们会阻止。一旦当前线程放弃了它的锁,另一个线程就可以获取锁。在优先级方面,即使一个线程的优先级高于另一个线程,也不能保证优先级较高的线程会 运行 优先于优先级较低的线程。
ReentrantLock class 构造函数提供了创建公平锁或非公平锁的可能性。在公平场景中,线程按照它们请求它的顺序获取对象上的锁。在不公平的情况下,允许插入请求,其中一个请求可能会插入请求队列中更高的位置。
Second question is regarding monitors, assume I have a the following code:
synchronized(someObject){
//do some stuff
someObject.wait();
}
Is it correct to assume that if a thread runs this code while another thread is waiting on the monitor and then the first thread calls wait, the second thread will enter the code block (I.E. the wait releases someObject's monitor) ?
当前线程调用wait时,当前线程会释放对该对象的所有锁。一旦该锁被释放,其他线程可能会尝试获取同一对象上的同一锁。
And last question is regarding a Singleton implementation, in order to make it thread safe is it enough to synchronize the instantiation line inside the singleton class to make sure it never gets called more than once ? and if so, is this the best practice ?
参见 this post 关于线程安全单例 classes.