`
mx19841031
  • 浏览: 76112 次
  • 性别: Icon_minigender_2
  • 来自: 西安
社区版块
存档分类
最新评论

对synchronized(this)的一些理解

阅读更多

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。



二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。



三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。



四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。



五、以上规则对其它对象锁同样适用.



举例说明:



一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。



package ths;

public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + " synchronized loop " + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();
}
}



结果:



A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4



二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。



package ths;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt2.m4t1();
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt2.m4t2();
}
}, "t2"
);
t1.start();
t2.start();
}
}



结果:



t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0



三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。



//修改Thread2.m4t2()方法:

public void m4t2() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

}



结果:



t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0



四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。



//修改Thread2.m4t2()方法如下:

public synchronized void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}



结果:



t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0



五、以上规则对其它对象锁同样适用:



package ths;

public class Thread3 {
class Inner {
private void m4t1() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t1()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
private void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}
}
private void m4t1(Inner inner) {
synchronized(inner) { //使用对象锁
inner.m4t1();
}
}
private void m4t2(Inner inner) {
inner.m4t2();
}
public static void main(String[] args) {
final Thread3 myt3 = new Thread3();
final Inner inner = myt3.new Inner();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt3.m4t1(inner);
}
}, "t1"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt3.m4t2(inner);
}
}, "t2"
);
t1.start();
t2.start();
}
}



结果:

尽管线程t1获得了对Inner的对象锁,但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。



t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0



现在在Inner.m4t2()前面加上synchronized:



private synchronized void m4t2() {
int i = 5;
while(i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : Inner.m4t2()=" + i);
try {
Thread.sleep(500);
} catch(InterruptedException ie) {
}
}
}



结果:

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁,所以t2对Inner.m4t2()的访问也被阻塞,因为m4t2()是Inner中的一个同步方法。



t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0

分享到:
评论

相关推荐

    java的线程同步机制synchronized关键字的理解_.docx

    Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中,synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...

    synchronized 的理解

    这意味着在任意时刻,都只有一个线程可以访问该实例的所有`synchronized`方法,或者进入由`synchronized(this)`标记的代码块。对于静态方法,锁对象则是该类的Class对象。 ```java public class MyClass { private...

    Android synchronized 测试案例

    `synchronized`关键字可以修饰方法或用作代码块,其主要作用是控制对共享资源的并发访问,防止数据不一致和竞态条件。当一个线程进入`synchronized`代码块或方法时,其他试图进入同一块的线程将被阻塞,直到持有锁的...

    深入理解java中的synchronized关键字

    - 如果一个线程在一个对象的`synchronized(this)`块中,其他线程仍然可以访问该对象的非`synchronized(this)`代码块。 - 对象锁仅适用于该对象的`synchronized`代码块,不影响其他线程对其他对象的访问。 以下是...

    synchronized用法大全实例

    在Java多线程编程中,`synchronized`关键字是一个至关重要的工具,用于实现线程间的同步,以确保共享资源的安全访问。本实例大全将全面解析`...理解并熟练使用`synchronized`,是编写健壮的多线程Java程序的基础。

    JAVA面试题 简谈你对synchronized关键字的理解

    JAVA面试题简谈你对synchronized关键字的理解 Synchronized关键字是Java语言中的一种同步机制,主要用于解决多线程之间的同步问题。下面我们将详细介绍synchronized关键字的特性、用法和注意事项。 Synchronized...

    JAVA synchronized详解

    为了更好地理解`synchronized`的工作原理,我们来看两个示例。 ##### 示例1:同步方法 下面的代码展示了一个使用同步方法的例子,其中定义了一个`Thread1`类,实现了`Runnable`接口。在这个类中,`run()`方法被`...

    synchronized详解

    理解`synchronized`的关键在于识别它锁定的是哪个对象。在方法级别,锁是`this`或`static`方法所属的Class对象;在同步块中,锁是块内指定的对象。同时,应该谨慎使用`synchronized`,因为它会引入性能开销,并可能...

    java synchronized demo

    在Java编程语言中,`...总结,`java synchronized demo`是一个关于如何在Java中使用`synchronized`关键字进行线程同步的示例,通过理解和实践这个例子,开发者可以更好地掌握多线程环境下数据安全和同步的重要性。

    javasynchronized详解.pdf

    Java中的`synchronized`关键字是用于实现线程同步的重要机制,它的主要目的是确保在多线程环境中,对于共享资源的访问能够保持线程安全。...理解并熟练运用`synchronized`可以帮助开发者编写出更加健壮的多线程程序。

    java-synchronized详解.doc

    对于一些复杂场景,如读写操作,`synchronized`可能不是最佳选择,可以考虑使用`java.util.concurrent`包中的高级并发工具,如`ReentrantLock`、`Semaphore`等。 总结来说,`synchronized`是Java中实现线程同步的...

    Java synchronized关键_动力节点Java学院整理

    在提供的示例中,`MyRunable`类的`run()`方法使用`synchronized(this)`代码块,这里的`this`指的是`MyRunable`对象。由于`t1`和`t2`都基于同一个`Runnable`对象`demo`创建,所以它们共享`demo`的锁。当一个线程执行`...

    实例解析Java中的synchronized关键字与线程平安问题_.docx

    但是,很多开发者对 synchronized 关键字的理解并不够深入,本文将通过实例解析 Java 中的 synchronized 关键字与线程平安问题,帮助开发者更好地理解和使用 synchronized 关键字。 首先,需要清晰的是 ...

    Javasynchronized机制.pdf

    在Java编程语言中,`synchronized`关键字是用于处理多线程并发访问共享资源时的同步控制机制。它确保了在同一时刻,...理解`synchronized`的工作原理以及如何正确应用它,对于编写健壮的多线程Java应用程序至关重要。

    使用synchronized实现多线程同步.pdf

    这篇文档主要讨论了如何使用`synchronized`关键字来控制多线程对共享数据的访问。 首先,`synchronized`关键字有两种主要的用法:修饰实例方法和修饰代码块。当`synchronized`用于修饰实例方法时,它会锁定当前对象...

    同步代码块(synchronized).zip

    在Java编程语言中,同步...理解并熟练使用`synchronized`关键字是Java多线程编程的基础,对于开发高效且线程安全的程序至关重要。在实际工作中,我们需要根据具体需求灵活运用同步代码块,以确保系统的正确性和稳定性。

    并发编程原理学习:synchronized关键字.doc

    `synchronized`关键字可以用于修饰方法或作为同步代码块,其核心目标是保证线程对共享资源的访问具有互斥性和可见性,防止数据不一致和竞态条件。 ### 同步代码块 同步代码块的形式如下: ```java synchronized ...

    PHP pthreads v3下同步处理synchronized用法示例

    $this-&gt;synchronized(function () { for ($i = 0; $i ; $i++) { ++$this-&gt;cnt; } }); } } ``` 在这个例子中,`add`方法中的整个for循环被`synchronized`包裹,确保每次只有一个线程能执行这段代码,从而避免...

    Java线程及同步(synchronized)样例代码

    通过具体的代码实现,我们将深入理解Java中的线程同步机制,并学习如何在实际编程中正确地使用这些机制。 #### 二、核心概念与原理 ##### 1. Java线程基础 Java中的线程是程序执行的基本单位,每个线程有自己的...

    Java 中 synchronized的用法详解(四种用法)

    理解 `synchronized` 的工作原理和用法对于编写线程安全的 Java 代码至关重要。然而,过度使用 `synchronized` 可能会导致性能下降,因为它会阻塞线程。因此,开发者需要谨慎地权衡同步的粒度,尽可能减少锁的范围,...

Global site tag (gtag.js) - Google Analytics