- 浏览: 342753 次
- 性别:
- 来自: 上海
-
文章分类
最新评论
-
alafqq：
很好的一篇启蒙hashmap的文章；HASHTABLE的93行 ...
使用数组和链表实现hash表存储信息 -
小帅1127：
我擦，我还以为有什么大坑呢，这也写出来。。。
if..else if和if..if的区别 -
fncj：
转下http://www.dodoer.com
hadoop单机版搭建图文详解 -
yueshang520：
Spring注解原理的详细剖析与实现 -
fncj：
转下，谢谢http://www.whohelpme.com/b ...
Spring注解原理的详细剖析与实现
1、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
2、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问object中的非synchronized(this)同步代码块。
3、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其他synchronized(this)同步代码块得访问将被阻塞。
4、第三个例子同样适用其他同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其他线程对该object对象所有同步代码部分的访问都将被暂时阻塞。
5、以上规则对其他对象锁同样适用
一、
public class Thread1 implements Runnable{
/**
* 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。
* 另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块
* @param args
*/
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();
}
@Override
public void run() {
synchronized(this){
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+" synchronized loop "+i);
}
}
}
}
执行结果：
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
二、
package review.testSynchronized;
public class Thread2 implements Runnable {
/**
* 然而，当一个线程访问object的一个synchronized(this)同步代码块时，
* 另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
* @param args
*/
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();
}
public void m4t1(){
synchronized(this){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void m4t2(){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
public void run() {
}
}
执行结果：
t1 : 4
t1 : 3
t1 : 2
t1 : 1
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0
t1 : 0
三、
执行结果：package review.testSynchronized;
public class Thread3 {
/**
* 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，
* 其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
* @param args
*/
public static void main(String[] args) {
final Thread3 myt2=new Thread3();
Thread t1=new Thread(
new Runnable(){
public void run(){
myt2.m4t1();
}
},"Thread3_t1"
);
Thread t2=new Thread(
new Runnable(){
public void run(){
myt2.m4t2();
}
},"Thread3_t2"
);
t1.start();
t2.start();
}
public void m4t1(){
synchronized(this){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void m4t2(){
synchronized(this){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
Thread3_t1 : 4
Thread3_t1 : 3
Thread3_t1 : 2
Thread3_t1 : 1
Thread3_t1 : 0
Thread3_t2 : 4
Thread3_t2 : 3
Thread3_t2 : 2
Thread3_t2 : 1
Thread3_t2 : 0
四、
package review.testSynchronized;
public class Thread4 {
/**
* 四、第三个例子同样适用其它同步代码块。
* 也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。
* 结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
* @param args
*/
public static void main(String[] args) {
final Thread4 myt4=new Thread4();
Thread t1=new Thread(
new Runnable(){
public void run(){
myt4.m4t1();
}
},"Thread4_t1"
);
Thread t2=new Thread(
new Runnable(){
public void run(){
myt4.m4t2();
}
},"Thread4_t2"
);
t1.start();
t2.start();
}
public void m4t1(){
synchronized(this){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void m4t2(){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+" : "+i);
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
执行结果：
Thread4_t1 : 4
Thread4_t1 : 3
Thread4_t1 : 2
Thread4_t1 : 1
Thread4_t1 : 0
Thread4_t2 : 4
Thread4_t2 : 3
Thread4_t2 : 2
Thread4_t2 : 1
Thread4_t2 : 0
五、
package review.testSynchronized;
public class Thread5 {
/**
* @param args
*/
public static void main(String[] args) {
final Thread5 myt5=new Thread5();
final Inner inner=myt5.new Inner();
Thread t1=new Thread(new Runnable(){
public void run(){
myt5.m4t1(inner);
}
},"Thread5_t1"
);
Thread t2=new Thread(new Runnable(){
public void run(){
myt5.m4t2(inner);
}
},"Thread5_t2"
);
t1.start();
t2.start();
}
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(Exception e){
}
}
}
private void m4t2(){
int i=5;
while(i-->0){
System.out.println(Thread.currentThread().getName()+":Inner.m4t2()="+i);
try{
Thread.sleep(500);
}catch(Exception e){
}
}
}
}
private void m4t1(Inner inner){
synchronized(inner){//使用对象锁
inner.m4t1();
}
}
private void m4t2(Inner inner){
inner.m4t2();
}
}
执行结果：
（尽管t1获得了对Inner的对象锁，但由于线程t2 访问的是同一个inner的非同步部分。所所以两个线程互不干扰）
Thread5_t1:Inner.m4t1()=4
Thread5_t2:Inner.m4t2()=4
Thread5_t2:Inner.m4t2()=3
Thread5_t1:Inner.m4t1()=3
Thread5_t2:Inner.m4t2()=2
Thread5_t1:Inner.m4t1()=2
Thread5_t2:Inner.m4t2()=1
Thread5_t1:Inner.m4t1()=1
Thread5_t1:Inner.m4t1()=0
Thread5_t2:Inner.m4t2()=0
现在在Inner.m4t2()前面加上synchronized:
(尽管t1与t2访问了同一个对象中两个毫不相干的部分，但因为t1先获得了对对象Inner的对象锁，所以t2对Inner.m4t2()的访问也被阻塞，因为m4t2()是Inner中的一个同步方法)
Thread5_t1:Inner.m4t1()=4
Thread5_t1:Inner.m4t1()=3
Thread5_t1:Inner.m4t1()=2
Thread5_t1:Inner.m4t1()=1
Thread5_t1:Inner.m4t1()=0
Thread5_t2:Inner.m4t2()=4
Thread5_t2:Inner.m4t2()=3
Thread5_t2:Inner.m4t2()=2
Thread5_t2:Inner.m4t2()=1
Thread5_t2:Inner.m4t2()=0
发表评论
-
apache日志信息详解
2011-11-06 21:19 6319一、访问日志的格式 Apache内建了记录服务器 ... -
浏览器如何工作
2011-08-19 08:57 0http://taligarsiel.com/Projects ... -
编码实现用JDK中的Proxy实现springAOP功能
2011-08-18 15:04 792http://blog.csdn.net/iamtheevil ... -
Spring注解原理的详细剖析与实现
2011-08-14 23:09 84350本文主要分为三部分： ... -
Spring装配基本属性的原理分析与代码实现
2011-08-11 15:37 1481首先，做一个配置属性的基本测试。修改beans.xml,使引用 ... -
编码剖析Spring依赖注入的原理
2011-08-10 20:01 1868一、注入依赖对象 基本类型对象注入： <b ... -
Spring的三种实例化Bean的方法
2011-08-10 14:03 1Spring的三种实例化Bean的方法 1、 使用 ... -
Spring管理bean的原理自定义实现
2011-08-10 10:44 62441、Spring通过BeanDefinition管理基于S ... -
spring环境搭建与测试
2011-08-10 08:40 3473Chapter1、搭建与测试spring的环境 1、 ... -
java回调机制实现
2011-08-08 09:06 2107Java的接口支持提供了一种获得回调的等价功能的 ... -
log4j的使用与详细分析
2011-08-05 13:32 2692一、什么是log4j? http://logging.a ... -
log4j使用详解
2011-08-04 23:05 2http://logging.apache.org/log4j ... -
java解析XML的四种方法的学习与比较
2011-03-30 20:55 7294四种XML解析方法： ... -
自定义日志模块实现
2011-03-30 09:58 1167package wxy.XXXX.Utils; impo ... -
详细解析Java中抽象类和接口的区别（转）
2011-03-24 23:48 975在Java语言中， abstract cl ... -
NIO学习笔记（三）---通道
2011-03-09 23:06 16041、通道基础 ... -
NIO学习笔记（2）--缓冲区
2011-03-09 18:20 9891、一个Buffer对象是固定数量的数据的容器。其作用是 ... -
封锁管理子系统模拟实现java版
2011-03-09 18:01 1247封锁管理子系统模拟实现 文件锁定 ... -
NIO学习笔记（一）I/O缓冲区操作
2011-03-07 20:04 1286上图简单描述了数据从外部磁盘向运行中的进程的内存区域移动的 ... -
四种参数传递机制的比较与分析
2011-02-16 23:21 1907一、所有程序设计语言都有关于过程的概念，但是在这些 ...
相关推荐
synchronized (this) { //….. } } this 指的是调用这个方法的对象，如 P1。可见同步方法实质是将 synchronized 作用于 object reference。 Synchronized 关键字也可以用作语句块，它锁定的对象可以是任何对象...
本文将深入探讨`synchronized`的几种使用示例，包括方法加锁、代码块加锁（针对`this`和对象）以及静态方法加锁。 1. **方法加锁** 当在实例方法前使用`synchronized`关键字时，它会锁定当前对象的监视器，只有...
- 如果一个线程正在访问对象的`synchronized(this)`同步代码块，其他线程仍然可以访问该对象的非`synchronized(this)`代码块。例如： ```java package ts; public class Thread2 { public void m4t1() { ...
synchronized (this) { // ... } } } ``` 在上面的例子中，synchronized 关键字被用于代码块中，以实现对当前对象的互斥访问控制。 三、synchronized 关键字的继承 synchronized 关键字不能被继承，即基类的 ...
synchronized (this) { // 代码块 } } ``` 在上述案例中，`this`表示当前对象实例，也可以替换为其他对象实例，实现对特定对象的同步。 三、同步多个对象 在多对象同步中，可以通过锁定不同的对象实例来实现对...
在学习Java过程中，自己收集了很多的Java的学习资料，分享给大家，有需要的欢迎下载，希望对大家有用，一起学习，一起进步。
synchronized (this) { balance += amount; } } public void withdraw(double amount) { synchronized (this) { if (balance >= amount) { balance -= amount; } else { System.out.println(...
以下是一个具体的示例程序，用于演示多个线程访问同一个对象的`synchronized(this)`同步代码块时的行为。 ```java package threads; public class Thread1 implements Runnable { public void run() { ...
synchronized (this) { for (int i = 0; i ; i++) { System.out.println(Thread.currentThread().getName() + " synchronized loop " + i); } } } public static void main(String[] args) { Thread1 t1 = ...
synchronized (this) { count++; } } // 使用自定义锁 private final Object lock = new Object(); public void incrementWithCustomLock() { synchronized (lock) { count++; } } } ``` #### 性能...
`synchronized`关键字在Java编程语言中扮演着至关重要的角色，它是Java实现多线程同步的主要机制。通过使用`synchronized`，可以确保同一时间只有一个线程能够执行特定代码块，从而防止数据的不一致性和线程安全问题...
这意味着在任意时刻，都只有一个线程可以访问该实例的所有`synchronized`方法，或者进入由`synchronized(this)`标记的代码块。对于静态方法，锁对象则是该类的Class对象。 ```java public class MyClass { private...
同步方法会隐式地使用`this`作为监视器对象，或者对于静态方法，监视器对象是对应的类的Class实例。 3. **监视器对象**： - 监视器对象是用于锁定的目标，可以是任何对象。在同步代码块中，可以自定义对象作为...
- 示例2则演示了即使一个线程在一个`synchronized(this)`块中，其他线程仍可访问同一对象上的非`synchronized(this)`代码块，因为这些代码块没有受到当前对象锁的保护。 5. **锁的粒度**： - `synchronized`...
abstract boolean break byte case catch char class const continue default do double else extends final finally float for goto if ...synchronized this throw throws transient try void volatile while null...
this.id = id; } @Override public void run() { // 获取当前线程的计数器 Integer counter = threadCounter.get(); System.out.println("Thread " + id + ": Counter is " + counter); // 更新计数器 ...
- 如果一个线程在一个对象的`synchronized(this)`块中，其他线程仍然可以访问该对象的非`synchronized(this)`代码块。 - 对象锁仅适用于该对象的`synchronized`代码块，不影响其他线程对其他对象的访问。 以下是...
例子二展示了即使在一个线程执行`synchronized(this)`代码块时，其他线程仍可以访问同一个对象中的非`synchronized`方法。线程A执行`synchronized`方法`m4t1()`，线程B可以同时执行非`synchronized`方法`m4t2()`。 ...