AtomicBoolean做什么,一个volatile布尔无法实现？
我想知道在声明变量as volatile和始终访问synchronized(this)Java 中的块中的变量之间的区别？
根据这篇文章,http://www.javamex.com/tutorials/synchronization_volatile.shtml有很多要说的,但也有很多不同之处,但也有一些相似之处.
我对这条信息特别感兴趣:
...
- 对volatile变量的访问永远不会阻塞:我们只进行简单的读或写操作,因此与synchronized块不同,我们永远不会持有任何锁;
- 因为访问volatile变量永远不会持有锁,所以它不适合我们想要读取update-write作为原子操作的情况(除非我们准备"错过更新");
read-update-write是什么意思？写入也不是更新,还是仅仅意味着更新是依赖于读取的写入？
最重要的是,何时更适合声明变量volatile而不是通过synchronized块访问变量？使用volatile依赖于输入的变量是一个好主意吗？例如,有一个变量被称为render通过渲染循环读取并由按键事件设置？
我阅读了一些关于该volatile关键字的文章,但我无法弄清楚它的正确用法.你能告诉我在C#和Java中它应该用什么吗？
我读到了下面的某个地方.
Java volatile关键字并不意味着原子,它常见的误解是,在声明volatile之后,
++操作将是原子的,要使操作原子化,你仍然需要确保使用synchronizedJava中的方法或块进行独占访问 .
那么如果两个线程同时攻击一个volatile原始变量会发生什么呢？
这是否意味着,凡发生在它的锁,将要设置其值.如果在此期间,一些其他的线程来和读取旧值,而第一个线程正在改变它的价值,那么没有新的线程将读取其旧的价值？
Atomic和volatile关键字有什么区别？
我正在阅读Java中的volatile关键字并完全理解它的理论部分.
但是,我正在寻找的是一个很好的案例,它展示了如果变量不是易变的话会发生什么.
下面的代码片段无法正常工作(来自aioobe)
class Test extends Thread {
boolean keepRunning = true;
public void run() {
while (keepRunning) {
}
System.out.println("Thread terminated.");
}
public static void main(String[] args) throws InterruptedException {
Test t = new Test();
t.start();
Thread.sleep(1000);
t.keepRunning = false;
System.out.println("keepRunning set to false.");
}
}
理想情况下,如果keepRunning不是volatile,则线程应该继续无限运行.但是,它会在几秒钟后停止.
我有两个基本问题: -
这是我的单例模式的自定义类.在这段代码中,我使用双重检查锁定如下.当我在某些源上阅读很多帖子时,他们说双重检查很有用,因为它可以防止两个并发线程同时运行产生两个不同的对象.
public class DoubleCheckLocking {
public static class SearchBox {
private static volatile SearchBox searchBox;
// private constructor
private SearchBox() {}
// static method to get instance
public static SearchBox getInstance() {
if (searchBox == null) { // first time lock
synchronized (SearchBox.class) {
if (searchBox == null) { // second time lock
searchBox = new SearchBox();
}
}
}
return searchBox;
}
}
我仍然不太了解上面的代码.如果两个线程在实例为空时一起运行相同的代码行,会出现什么问题？
if (searchBox == null) {
synchronized (SearchBox.class) {
if (searchBox == null) {
searchBox = …我理解read-acquire(在它之后没有重新排序后续的读/写操作)和write-release(不重新排序它之前的读/写操作).我的q是: -
读取和读取相同,与易失性读取相同,写入发布与Java中的易失性写入相同吗？
为什么这很重要的是,让我们来看看写释放的情况.
y = x; // a read.. let's say x is 1 at this point
System.out.println(y);// 1 printed
//or you can also consider System.out.println(x);
write_release_barrier();
//somewhere here, some thread sets x = 2
ready = true;// this is volatile
System.out.println(y);// or maybe, println(x).. what will be printed?
此时,是x 2还是1？在这里,考虑准备挥发.据我所知,volatile之前的所有商店都将首先显示出来......然后只有volatile才能显示出来.谢谢.
参考: - http://preshing.com/20120913/acquire-and-release-semantics/
我和老师就volatilejava中的关键字进行了一些争论.说变量被声明为volatile:
该变量的值永远不会被线程本地缓存:所有读取和写入将直接进入"主存储器".
我老师的意见是:
volatile关键字不保证变量的值将保存在主内存中.
有人能解决我们的冲突吗？谢谢!
我试图通过使用wait()和notify()访问共享资源或依赖其状态来理解实现线程的必要性.
我看到的想法是监视对象并等待它们的可用性并在使用后释放它们以使它们可用于其他线程/方法,但为什么这些方法是必要的而不是仅仅将相关对象声明为静态volatile以便其他线程在不调用这些方法的情况下了解状态的变化？
例如
在一家餐厅,有2名厨师.其中一位厨师是一位优秀的厨师(更好的烹饪品质,......)并带有布尔值isGoodCook = true,而第二位厨师则是一名厨师并带有布尔值isGoodCook = false.
一个厨师只有一次可以做饭的设备.糟糕的厨师会在特定的时间内做饭(=烹饪时间),而优秀的厨师偶尔会来厨房来接管糟糕的厨师做饭的任务.这位优秀的厨师在他的烹饪过程中永远不会被打断,并且一旦开始他就会为他的整个烹饪时间做饭.
(坏厨师停止烹饪,只要好厨师做饭的一部分(=烹饪时间的好厨师)).
在好厨师停止做饭之后,坏厨师必须再次进行准备饭菜的任务.
private boolean cooking; //is equipment used at the moment
private boolean isGoodCook;
private boolean cookingDesire; //indicating to chef to stop cooking
private int cookingTime;
public CookingTask(boolean isGoodCook, int cookingTime)
{
this.isGoodCook = isGoodCook;
this.cookingTime = cookingTime;
}
public void run()
{
if(isGoodCook)
{
//notify actual cook to stop cooking
cookingDesire = true;
}
//wait til equipment to cook
//is …