synchronized Java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。
先看几个例子:
实例一:
import java.util.ArrayList;
import java.util.List;
public class MyThread {
public void printNum(List list) {
synchronized (list) {
if (null != list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static List getList() {
List list = new ArrayList();
for (int i = 1; i <= 5; i++) {
list.add(i);
}
return list;
}
public static void main(String[] args) {
final MyThread mt = new MyThread();
final MyThread mt1 = new MyThread();
final List list = mt.getList();
Thread t1 = new Thread(new Runnable(){
public void run() {
mt.printNum(list);
}
}, "t1");
Thread t2 = new Thread(new Runnable(){
public void run() {
mt1.printNum(list);
}
}, "t2");
t1.start();
t2.start();
}
}
输出结果:
t1:1
t1:2
t1:3
t1:4
t1:5
t2:1
t2:2
t2:3
t2:4
t2:5
实例二:
import java.util.ArrayList;
import java.util.List;
public class MyThread {
public void printNum(List list) {
synchronized (list) {
if (null != list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static List getList() {
List list = new ArrayList();
for (int i = 1; i <= 5; i++) {
list.add(i);
}
return list;
}
public static void main(String[] args) {
final MyThread mt = new MyThread();
final MyThread mt1 = new MyThread();
final List list = mt.getList();
final List list1 = new ArrayList();
for (int i = 1; i <= 5; i++) {
list1.add(i);
}
Thread t1 = new Thread(new Runnable(){
public void run() {
mt.printNum(list);
}
}, "t1");
Thread t2 = new Thread(new Runnable(){
public void run() {
mt1.printNum(list1);
}
}, "t2");
t1.start();
t2.start();
}
}
输出结果:
t1:1
t2:1
t1:2
t2:2
t2:3
t1:3
t1:4
t2:4
t2:5
t1:5
实例三:
import java.util.ArrayList;
import java.util.List;
public class MyThread {
public void printNum(List list) {
synchronized (this) {
if (null != list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static List getList() {
List list = new ArrayList();
for (int i = 1; i <= 5; i++) {
list.add(i);
}
return list;
}
public static void main(String[] args) {
final MyThread mt = new MyThread();
final MyThread mt1 = new MyThread();
final List list = mt.getList();
final List list1 = new ArrayList();
for (int i = 1; i <= 5; i++) {
list1.add(i);
}
Thread t1 = new Thread(new Runnable(){
public void run() {
mt.printNum(list);
}
}, "t1");
Thread t2 = new Thread(new Runnable(){
public void run() {
mt1.printNum(list1);
}
}, "t2");
t1.start();
t2.start();
}
}
输出结果:
t1:1
t2:1
t1:2
t2:2
t1:3
t2:3
t1:4
t2:4
t1:5
t2:5
实例四:
import java.util.ArrayList;
import java.util.List;
public class MyThread {
public void printNum(List list) {
synchronized (this) {
if (null != list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static List getList() {
List list = new ArrayList();
for (int i = 1; i <= 5; i++) {
list.add(i);
}
return list;
}
public static void main(String[] args) {
final MyThread mt = new MyThread();
final MyThread mt1 = new MyThread();
final List list = mt.getList();
final List list1 = new ArrayList();
for (int i = 1; i <= 5; i++) {
list1.add(i);
}
Thread t1 = new Thread(new Runnable(){
public void run() {
mt.printNum(list);
}
}, "t1");
Thread t2 = new Thread(new Runnable(){
public void run() {
mt.printNum(list1);
}
}, "t2");
t1.start();
t2.start();
}
}
输出结果:
t1:1
t1:2
t1:3
t1:4
t1:5
t2:1
t2:2
t2:3
t2:4
t2:5
实例五:
public class MyThread {
public void printNum(List list) {
synchronized (list) {
if (null != list) {
for (int i = 0; i < list.size(); i++) {
System.out.println(Thread.currentThread().getName() + ":"+ list.get(i));
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static List getList() {
List list = new ArrayList();
for (int i = 1; i <= 5; i++) {
list.add(i);
}
return list;
}
public static void main(String[] args) {
final MyThread mt = new MyThread();
final MyThread mt1 = new MyThread();
final List list = mt.getList();
final List list1 = new ArrayList();
for (int i = 1; i <= 5; i++) {
list1.add(i);
}
Thread t1 = new Thread(new Runnable(){
public void run() {
mt.printNum(list);
}
}, "t1");
Thread t2 = new Thread(new Runnable(){
public void run() {
mt.printNum(list1);
}
}, "t2");
t1.start();
t2.start();
}
}
输出结果:
t1:1
t2:1
t1:2
t2:2
t2:3
t1:3
t1:4
t2:4
t2:5
t1:5
由以上实例可以得出,不同的线程调用的必须是同一个对象,并且该对象与synchronized 锁的对象是同一个类时,才能够保证在同一时刻最多只有一个线程执行该段代码。
分享到:
相关推荐
在Android开发中,`synchronized`关键字是Java语言中用于实现线程同步的重要工具,它在多线程环境下确保了共享资源的安全访问。本测试案例深入探讨了`synchronized`的使用方法,包括同步单个对象、同步多个对象以及...
本实例大全将全面解析`synchronized`的使用方式,包括同步方法、同步语句块、类锁和对象锁。 ### 1. 同步方法 同步方法是通过在方法声明前加上`synchronized`关键字实现的。这样,同一时间只有一个线程可以执行该...
1. **synchronized实例方法**: 当一个方法被声明为`synchronized`时,这意味着该方法在同一时间只能被一个线程访问。如果两个线程试图访问同一个对象的`synchronized`实例方法,只有一个线程能够获取到该对象的锁...
在Java中,`synchronized`关键字有两种用法:修饰实例方法和修饰代码块。对于实例方法,整个方法体被视为同步区域;对于代码块,可以指定特定的监视器对象,只有获得该对象锁的线程才能进入。 例如: ```java ...
对象锁是针对类的实例对象而言的,当一个线程访问某个对象的非静态 synchronized 方法或同步代码块时,会获取到该对象的锁。这种锁确保了同一时间只有一个线程能访问该对象的成员变量。例如: ```java public class...
静态方法:一个线程获取了该对象的锁之后,其他线程来访问其他Synchronized实例方法时无法获取该对象的锁,就不能访问该对象的其他Synchronized实例方法。 同步方法块:使用Synchronized修饰代码块,可以确保线程...
1. 对象实例范围:synchronized 关键字可以被用于对象实例的方法上,以防止多个线程同时访问同一个对象的 synchronized 方法。例如: ```java public class MyClass { public synchronized void myMethod() { // ....
当`synchronized`作用于实例方法时,它锁定的是调用该方法的对象实例,这意味着在同一时间,只有一个线程可以执行该对象上的同步方法。如果存在多个对象实例,即使它们的同步方法相同,不同实例的同步方法也可以同时...
`synchronized`关键字主要有两种用法:修饰实例方法和同步代码块。当一个方法被`synchronized`修饰时,同一时间只能有一个线程访问该方法,其他试图访问的线程会被阻塞,直到当前线程执行完毕。这种方式保证了同一...
- **实例方法**:可以直接将`synchronized`关键字放在实例方法前,此时该方法的锁为当前对象实例本身。 ```java public synchronized void method() { // 同步方法体 } ``` - 当一个线程调用此方法时,会锁定...
这里的`object`通常是共享资源的实例引用。 二、`synchronized`的作用 1. **线程互斥**:当一个线程在执行`synchronized`代码时,其他线程必须等待该线程释放锁后才能进入。 2. **内存可见性**:确保线程在读取或...
`synchronized`关键字在Java编程语言中扮演着至关重要的角色,它是Java实现多线程同步的主要机制。通过使用`synchronized`,可以确保同一时间只有一个线程能够执行特定代码块,从而防止数据的不一致性和线程安全问题...
当在实例方法前使用`synchronized`关键字时,它会锁定当前对象的监视器,只有拥有该监视器的线程才能执行该方法。例如: ```java public class Counter { private int count = 0; public synchronized void ...
在售票示例中,我们可以用`this`作为监视器对象,因为它代表当前类的实例: ```java public void run() { for (int i = 0; i ; i++) { if (this.ticket > 0) { synchronized (this) { // 休眠1s try { ...
- **实例方法同步**:如果在类的方法前加上`synchronized`,那么该方法称为同步方法。每次只有一个线程能访问该方法,其他线程需要等待。 - **静态方法同步**:静态方法的同步是针对类级别的,这意味着所有线程都将...
从输出结果可以看出,线程`t1`和`t2`分别执行了各自的循环,但它们是交替进行的,这是因为它们都尝试获取同一个对象(即`Thread2`实例)的锁。 #### 四、总结 `synchronized`关键字是Java中实现线程安全的重要手段...
但是,很多开发者对 synchronized 关键字的理解并不够深入,本文将通过实例解析 Java 中的 synchronized 关键字与线程平安问题,帮助开发者更好地理解和使用 synchronized 关键字。 首先,需要清晰的是 ...
本篇将深入探讨`synchronized`修饰方法在Java多线程程序中的使用实例。 1. **同步方法** 同步方法是通过在方法声明前加上`synchronized`关键字来实现的。当一个方法被声明为同步时,意味着在同一时刻只有一个线程...
当`synchronized`用于修饰实例方法时,其锁对象是当前对象的实例。这意味着在任意时刻,都只有一个线程可以访问该实例的所有`synchronized`方法,或者进入由`synchronized(this)`标记的代码块。对于静态方法,锁对象...
- **解释**:线程`A`和线程`B`共享同一个`Thread1`实例`t1`,因此当线程`A`获取到`t1`的锁并执行`synchronized(this)`内的代码时,线程`B`将被阻塞,直到线程`A`释放锁。 2. **同步代码块与非同步代码块的访问** ...