第一篇：
Java语言的关键字，当它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
一、当两个并发线程访问同一个对象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详解
Java中的`synchronized`关键字是用于实现线程同步的重要机制，它的主要目的是确保在多线程环境中，对于共享资源的访问能够保持线程安全。当`synchronized`关键字应用于方法或代码块时，它提供了互斥访问，即在任意...
### Java synchronized 关键字详解 #### 一、synchronized关键字简介 `synchronized`是Java语言提供的关键字之一，用于实现线程间的同步控制。通过在方法或代码块上使用`synchronized`，可以确保同一时间只有一个...
Java中的`synchronized`关键字是用来解决多线程环境下的并发访问问题，确保共享资源在同一时间只能被一个线程访问，从而避免数据的不一致性。在Java中，`synchronized`可以应用于方法或者代码块，实现线程同步。 1....
Java synchronized 详解 Java 中的同步机制是多线程编程中最重要的概念之一。它允许开发者控制多个线程对共享资源的访问，以避免数据不一致和race condition。这篇文章将详细介绍 Java 中的 synchronized 机制，...
### JAVA synchronized详解 在Java编程语言中，`synchronized`是一个非常重要的关键字，它主要用于实现同步控制机制。通过使用`synchronized`，可以确保同一时刻只有一个线程能够访问被标记为同步的方法或代码块，...
Java中的`synchronized`关键字是实现线程同步的关键机制，它保证了在多线程环境下，对共享资源的访问是互斥的，防止了数据竞争和不一致的问题。synchronized通过锁的概念来控制对代码块或方法的访问，分为两种形式：...
"Java 中 synchronized 用法详解" Synchronized 是 Java 语言中用于解决多线程共享数据同步问题的关键字。它可以作为函数的修饰符，也可以作为函数内的语句，用于实现同步方法和同步语句块。在 Java 中，...
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以保证数据的一致性和完整性。本文将深入解析`synchronized`在Java中的应用和工作原理。 一、`synchronized`的基本用法 `...
Java 中的 synchronized 用法详解 Java 中的 synchronized 关键字是用于解决多线程并发问题的重要工具之一。它可以被用于方法、代码块和变量上，以实现对共享资源的互斥访问控制。本文将对 Java 中的 synchronized ...
"Java 多线程与并发(4-26)-关键字- synchronized详解" Java 多线程与并发中的 synchronized 关键字是实现同步块的互斥访问和线程的阻塞及唤醒等工作的重要工具。下面将对 synchronized 关键字进行详细分析。 ...
5. **多线程**：Java提供了Thread类和Runnable接口来实现并发，还有同步机制如synchronized关键字，wait()、notify()和notifyAll()方法，以及线程池（ExecutorService）。 6. **网络编程**：Socket编程用于创建...
Java中的关键字synchronized 详解 Java中的关键字synchronized是Java语言中用于线程同步的关键字。它可以修饰方法或代码块，以便在多线程环境中保护共享资源的安全。 1、修饰普通方法 synchronized关键字可以修饰...
并发synchronized详解 在 Java 中，synchronized 是一种非常重要的关键字，用于解决多线程编程中的线程安全问题。线程安全问题是指多个线程同时访问同一个共享、可变资源时可能出现的错误或不一致情况。为了解决这...
Java 锁详解 Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是...
Java中的同步锁，即`synchronized`关键字，是Java多线程编程中用于解决并发问题的重要机制。它确保了对共享资源的互斥访问，防止数据的不一致性。当我们有多线程环境并涉及到共享数据时，可能会出现竞态条件，就像...
根据提供的信息，《java编程详解》是一本被广泛推荐并深受读者喜爱的专业书籍，它旨在为初学者和进阶学习者提供全面、深入的Java编程知识。以下是对该书可能涵盖的一些核心知识点的概述： ### Java语言基础 1. **...
Java提供了多种同步机制，如`synchronized`关键字、`wait()`、`notify()`和`notifyAll()`方法，以及`Lock`接口（如`ReentrantLock`）等。通过这些机制，可以控制线程的执行顺序，确保数据的一致性和正确性。 线程组...