锁
在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。
synchronized同步
当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
举例说明:
1、Test1.java演示了4个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中
线程1调用method1
线程2调用method2
线程3调用method3
main也调用method3
不仅仅线程3和main是互斥的,实际上4个线程都是互斥的,因为他们都同步到了一个对象上（当前对象
synchronized (this)），所以对它们的方法依然是互斥的。
2、Test2.java演示了2个线程（包括main线程）试图进入某个类的同一个同步方法中，另外两个线程进入非同步方法。
线程1调用同步方法method1
线程2调用method2
线程3调用method3
main调用同步方法method1
线程1和main是互斥的，
如果先启动线程1，则线程1，线程2，线程3是独立进行的。执行完线程1，才会执行main
如果先启动线程main，则main，线程2，线程3是独立进行的。执行完main，才会执行线程1
3、Test3.java演示了三个线程试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized (obj1)，synchronized(obj2)，synchronized
(obj3)），所以这三个线程是独立进行的，并不是互斥的。
package com.jialin;
/**
* 抽象测试类
* @author jialin
*
*/
public abstract class AbstractTest {
public void Method1()
{}
public void Method2()
{}
public void Method3()
{}
}
package com.jialin;
import java.util.concurrent.TimeUnit;
/**
* 测试java 锁
* @author jialin
*
*/
public class Test1 extends AbstractTest{
public void Method1() {
//-----这一部分未加锁，可以运行到------begin---
System.out.println(Thread.currentThread().getName()
+ ":not synchronized part in Method1()");
//-----这一部分未加锁，可以运行到------end---
synchronized (this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method1("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void Method2() {
//-----这一部分未加锁，可以运行到------begin---
System.out.println(Thread.currentThread().getName()
+ ":not synchronized part in Method2()");
//-----这一部分未加锁，可以运行到------end---
synchronized (this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method2("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void Method3() {
//-----这一部分未加锁，可以运行到------begin---
System.out.println(Thread.currentThread().getName()
+ ":not synchronized part in Method3()");
//-----这一部分未加锁，可以运行到------end---
synchronized (this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method3("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
//初始化Test1对象
final AbstractTest ts = new Test1();
//线程1
Thread1 thread1=new Thread1(ts);
thread1.start();
//线程2
Thread2 thread2=new Thread2(ts);
thread2.start();
//线程3
Thread3 thread3=new Thread3(ts);
thread3.start();
//main线程
ts.Method3();
}
}
运行结果：
Thread-0:not synchronized part in Method1()
Thread-0:synchronized in Method1(0)
main:not synchronized part in Method3()
Thread-1:not synchronized part in Method2()
Thread-2:not synchronized part in Method3()
Thread-0:synchronized in Method1(1)
Thread-0:synchronized in Method1(2)
Thread-0:synchronized in Method1(3)
Thread-0:synchronized in Method1(4)
Thread-2:synchronized in Method3(0)
Thread-2:synchronized in Method3(1)
Thread-2:synchronized in Method3(2)
Thread-2:synchronized in Method3(3)
Thread-2:synchronized in Method3(4)
Thread-1:synchronized in Method2(0)
Thread-1:synchronized in Method2(1)
Thread-1:synchronized in Method2(2)
Thread-1:synchronized in Method2(3)
Thread-1:synchronized in Method2(4)
main:synchronized in Method3(0)
main:synchronized in Method3(1)
main:synchronized in Method3(2)
main:synchronized in Method3(3)
main:synchronized in Method3(4)
package com.jialin;
import java.util.concurrent.TimeUnit;
public class Test2 extends AbstractTest {
public synchronized void Method1() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method1("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void Method2() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":no synchronized in Method2("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void Method3() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":no synchronized in Method3("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
// 初始化Test1对象
final AbstractTest ts = new Test2();
// 线程1
Thread1 thread1 = new Thread1(ts);
thread1.start();
// 线程2
Thread2 thread2 = new Thread2(ts);
thread2.start();
//线程3
Thread3 thread3=new Thread3(ts);
thread3.start();
// main线程
ts.Method1();
}
}
运行结果：
Thread-0:synchronized in Method1(0)
Thread-1:no synchronized in Method2(0)
Thread-2:no synchronized in Method3(0)
Thread-0:synchronized in Method1(1)
Thread-1:no synchronized in Method2(1)
Thread-2:no synchronized in Method3(1)
Thread-1:no synchronized in Method2(2)
Thread-0:synchronized in Method1(2)
Thread-2:no synchronized in Method3(2)
Thread-1:no synchronized in Method2(3)
Thread-0:synchronized in Method1(3)
Thread-2:no synchronized in Method3(3)
Thread-1:no synchronized in Method2(4)
Thread-2:no synchronized in Method3(4)
Thread-0:synchronized in Method1(4)
main:synchronized in Method1(0)
main:synchronized in Method1(1)
main:synchronized in Method1(2)
main:synchronized in Method1(3)
main:synchronized in Method1(4)
package com.jialin;
import java.util.concurrent.TimeUnit;
public class Test3 extends AbstractTest {
private Object obj1=new Object();
private Object obj2=new Object();
private Object obj3=new Object();
public void Method1() {
synchronized (obj1) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method1("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void Method2() {
synchronized (obj2) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method2("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public void Method3() {
synchronized (obj3) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName()
+ ":synchronized in Method3("+i+")");
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
// 初始化Test1对象
final AbstractTest ts = new Test3();
// 线程1
Thread1 thread1 = new Thread1(ts);
thread1.start();
// 线程2
Thread2 thread2 = new Thread2(ts);
thread2.start();
//线程3
Thread3 thread3=new Thread3(ts);
thread3.start();
}
}
运行结果：
Thread-0:synchronized in Method1(0)
Thread-1:synchronized in Method2(0)
Thread-2:synchronized in Method3(0)
Thread-1:synchronized in Method2(1)
Thread-0:synchronized in Method1(1)
Thread-2:synchronized in Method3(1)
Thread-0:synchronized in Method1(2)
Thread-2:synchronized in Method3(2)
Thread-1:synchronized in Method2(2)
Thread-0:synchronized in Method1(3)
Thread-2:synchronized in Method3(3)
Thread-1:synchronized in Method2(3)
Thread-0:synchronized in Method1(4)
Thread-2:synchronized in Method3(4)
Thread-1:synchronized in Method2(4)
package com.jialin;
public class Thread1 extends Thread {
private AbstractTest ts;
public Thread1(AbstractTest ts)
{
this.ts=ts;
}
@Override
public void run() {
ts.Method1();
}
}
package com.jialin;
public class Thread2 extends Thread {
private AbstractTest ts;
public Thread2(AbstractTest ts) {
this.ts = ts;
}
@Override
public void run() {
ts.Method2();
}
}
package com.jialin;
public class Thread3 extends Thread {
private AbstractTest ts;
public Thread3(AbstractTest ts) {
this.ts = ts;
}
@Override
public void run() {
ts.Method3();
}
}
分享到：
相关推荐
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，以保证数据的一致性和完整性。这个关键词提供了互斥锁机制，防止多个线程同时执行同一段代码，确保了线程安全。 一、`...
在Java编程语言中，`synchronized`关键字是一个非常重要的概念，它用于实现线程同步，以确保多线程环境下的数据一致性与安全性。本示例"java synchronized demo"旨在探讨`synchronized`关键字的用法及其作用机制。...
Java中的`synchronized`关键字是多线程编程中用于同步控制的关键元素，它的主要目标是解决并发环境下多个线程对共享资源的访问冲突。在Java中，由于线程共享内存空间，如果没有适当的同步机制，可能会导致数据不一致...
"基于Java synchronized同步锁实现线程交互" Java多线程能够提高CPU利用效率，但也容易造成线程不安全、线程死锁等问题。Java synchronized同步锁可以保证同一时刻只有一个线程操作同一资源，使用wait()、notify()...
### Java synchronized 关键字原理与自定义锁实现详解 #### 一、Java synchronized 关键字原理 `synchronized` 是 Java 中的关键字之一，用于实现线程间的同步控制，确保共享资源的安全访问。它主要应用于以下两种...
Java synchronized关键字是Java多线程编程中至关重要的一个概念，它用于实现线程同步，确保在并发环境下数据的一致性和完整性。这篇文档主要探讨了Java synchronized的锁机制，包括锁粗化、偏向锁、轻量级锁、重量级...
### JAVA synchronized详解 在Java编程语言中，`synchronized`是一个非常重要的关键字，它主要用于实现同步控制机制。通过使用`synchronized`，可以确保同一时刻只有一个线程能够访问被标记为同步的方法或代码块，...
"Java 中 synchronized 用法详解" Synchronized 是 Java 语言中用于解决多线程共享数据同步问题的关键字。它可以作为函数的修饰符，也可以作为函数内的语句，用于实现同步方法和同步语句块。在 Java 中，...
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源，确保数据的正确性和一致性。在Java中，每个对象都有一个与之关联的锁，也称为同步锁，它允许线程在访问共享资源时进行互斥...
Java synchronized 学习 Java 中的 synchronized 关键字是用来实现线程同步的，它可以用来修饰方法、代码块和静态方法，以确保在多线程环境下数据的一致性。 一、进程和线程的区别 在计算机中，每个运行着的 xxxx...
"Java 锁机制 Synchronized" Java 锁机制 Synchronized 是 Java 语言中的一种同步机制，用于解决多线程并发访问共享资源时可能出现的一些问题。 Java 锁机制 Synchronized 的概念 在 Java 中，每个对象都可以被...
在Java多线程编程中，`synchronized`关键字是一个至关重要的工具，用于实现线程间的同步，以确保共享资源的安全访问。本实例大全将全面解析`synchronized`的使用方式，包括同步方法、同步语句块、类锁和对象锁。 ##...
java synchronized详解
Java中的`synchronized`关键字是多线程编程中的一个重要概念，用于控制并发访问共享资源时的同步机制。在Java中，当多个线程试图同时访问和修改同一块代码或数据时，可能会导致数据不一致的问题。为了解决这个问题，...
Java中的`synchronized`关键字是用于实现线程同步的重要机制，它的主要目的是确保在多线程环境中，对于共享资源的访问能够保持线程安全。当`synchronized`关键字应用于方法或代码块时，它提供了互斥访问，即在任意...
在Java编程语言中，`synchronized`关键字是用于处理多线程并发访问共享资源时的同步控制机制。它确保了在同一时刻，只有一个线程能够执行特定的代码块或方法，从而避免了数据的不一致性问题。以下是对`synchronized`...
Java中的`synchronized`关键字是用来解决多线程环境下的并发访问问题，确保共享资源在同一时间只能被一个线程访问，从而避免数据的不一致性。在Java中，`synchronized`可以应用于方法或者代码块，实现线程同步。 1....
Java中的`synchronized`关键字是实现线程同步的关键机制，它确保了在多线程环境下对共享资源的访问得以正确协调，防止数据不一致和竞态条件的发生。在Java语言中，支持多线程是一个核心特性，而`synchronized`就是...
由浅入深解析synchronized锁的机制，各种锁的概念的介绍，膨胀过程，基于redis的分布式锁demo。