Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码块。
Note:
当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞
1.方法声明时使用,放在范围操作符(public等)之后,返回类型声明(void等)之前.这时,线程获得的是成员锁,即一次只能有一个线程进入该方法,其他线程要想在此时调用该方法,只能排队等候,当前线程(就是在synchronized方法内部的线程)执行完该方法后,别的线程才能进入.
例如:
public synchronized void synMethod(){
//方法体
}
如在线程t1中有语句obj.synMethod(); 那么由于synMethod被synchronized修饰,在执行该语句前, 需要先获得调用者obj的对象锁, 如果其他线程(如t2)已经锁定了obj (可能是通过obj.synMethod,也可能是通过其他被synchronized修饰的方法obj.otherSynMethod锁定的obj), t1需要等待直到其他线程(t2)释放obj, 然后t1锁定obj, 执行synMethod方法. 返回之前之前释放obj锁.
2.对某一代码块使用,synchronized后跟括号,括号里是变量,这样,一次只有一个线程进入该代码块.此时,线程获得的是成员锁
public class SynchronizedField {
private static Double balance = 100.0;
public static void main(String[] args) {
lockField();
}
public static void lockField() {
Thread withDrawThread = new WithdrawThread(10.0);
Thread depositThread = new Thread(new DepositThread(10.0));
withDrawThread.start();
depositThread.start();
}
private static final class WithdrawThread extends Thread {
private Double amount;
public WithdrawThread(Double amount) {
this.amount = amount;
}
public void run() {
synchronized (balance) {
System.out.println("Before withdrawing " + amount + ", the balance is " + balance);
balance -= amount;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Withdrew " + amount + ", the balance is " + balance);
}
}
}
private static final class DepositThread implements Runnable {
private Double amount;
public DepositThread(Double amount) {
this.amount = amount;
}
public void run() {
synchronized (balance) {
System.out.println("Before depositing " + amount + ", the balance is " + balance);
balance += amount;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Deposited " + amount + ", the balance is " + balance);
}
}
}
}
public class SynchronizedMethod {
private static Double balance = 100.0;
public static void main(String[] args) {
lockMethod();
}
public static void lockMethod() {
Thread depositThread1 = new Thread(new DepositThread(10.0));
Thread depositThread2 = new Thread(new DepositThread(10.0));
depositThread1.start();
depositThread2.start();
}
private static final class DepositThread implements Runnable {
private Double amount;
public DepositThread(Double amount) {
this.amount = amount;
}
public void run() {
deposit(amount);
}
}
public static synchronized void deposit(Double amount) {
System.out.println("Before depositing " + amount + ", the balance is " + balance);
balance += amount;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Deposited " + amount + ", the balance is " + balance);
}
}
Notes：
deposit方法不能写在DepositThread里
class lock和object lock
public class LearnVolatile {
public synchronized void SyncForInstance() {
for(int i=0; i<10; i++) {
System.out.println("SyncForInstance");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static synchronized void SyncForClass() {
for(int i=0; i<10; i++) {
System.out.println("SyncForClass");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static Thread t1 = new Thread() {
public void run() {
SyncForClass();
}
};
static Thread t2 = new Thread() {
public void run() {
new LearnVolatile().SyncForInstance();
}
};
public static void main(String[] args) {
t1.start();
t2.start();
}
}
结果如下：
SyncForClass
SyncForInstance
SyncForClass
SyncForInstance
……
public class LearnVolatile {
private static Lock lock = new ReentrantLock();
public void SyncForInstance() {
try {
lock.lock();
for(int i=0; i<10; i++) {
System.out.println("SyncForInstance");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
lock.unlock();
}
}
public static void SyncForClass() {
try {
lock.lock();
for(int i=0; i<10; i++) {
System.out.println("SyncForClass");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} finally {
lock.unlock();
}
}
static Thread t1 = new Thread() {
public void run() {
SyncForClass();
}
};
static Thread t2 = new Thread() {
public void run() {
new LearnVolatile().SyncForInstance();
}
};
public static void main(String[] args) {
t1.start();
t2.start();
}
}
结果如下：
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForClass
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
SyncForInstance
Exception 1
public class LearnThread {
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
System.out.println("....");
}
};
t1.start();
t1.start();
}
}
....
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:704)
at com.jesse.core.learnvolatile.LearnThread.main(LearnThread.java:12)
Reason：线程的生命周期（dead）
①NEW：这种情况指的是，通过New关键字创建了Thread类（或其子类）的对象
②RUNNABLE：这种情况指的是Thread类的对象调用了start()方法，这时的线程就等待时间片轮转到自己这，以便获得CPU；第二种情况是线程在处于RUNNABLE状态时并没有运行完自己的run方法，时间片用完之后回到RUNNABLE状态；还有种情况就是处于BLOCKED状态的线程结束了当前的BLOCKED状态之后重新回到RUNNABLE状态。
③RUNNING：这时的线程指的是获得CPU的RUNNABLE线程，RUNNING状态是所有线程都希望获得的状态。
④DEAD：处于RUNNING状态的线程，在执行完run方法之后，就变成了DEAD状态了。
⑤BLOCKED：这种状态指的是处于RUNNING状态的线程，出于某种原因，比如调用了sleep方法、等待用户输入等而让出当前的CPU给其他的线程。
简单的死锁
public class DeadLock {
private static Lock lockA = new ReentrantLock();
private static Lock lockB = new ReentrantLock();
public static void main(String[] args) {
Thread t1 = new Thread() {
public void run() {
try {
lockA.lock();
System.out.println("t1 get lockA");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1 is waiting lockB");
lockB.lock();
} finally {
lockA.unlock();
lockB.unlock();
}
}
};
Thread t2 = new Thread() {
public void run() {
try {
lockB.lock();
System.out.println("t2 got lockB");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2 is waiting for lockA");
lockA.lock();
} finally {
lockB.unlock();
lockA.unlock();
}
}
};
t1.start();
t2.start();
}
}
t2 got lockB
t1 get lockA
t2 is waiting for lockA
t1 is waiting for lockB
分享到：
相关推荐
你还在用synchronized？线程安全相关知识深入剖析
synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果 再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class ...
java锁机制Synchronized java锁机制Synchronized java锁机制Synchronized java锁机制Synchronized
java中synchronized用法
java synchronized的一些小实验，对帮助理解synchronized的使用有一定的帮助。
java里面synchronized用法
Synchronized锁在Spring事务管理下，导致线程不安全。
synchronized的几种示例研究,方法加锁，代码块加锁（this和对象）以及静态方法加锁的示例和效果。基本上包含了synchronized的几种常用的方式。
java多线程中synchronized关键字的用法 解压密码 www.jiangyea.com
This document specifies the third version of the Synchronized Multimedia Integration Language (SMIL, pronounced "smile"). SMIL 3.0 has the following design goals: ● Define an XML-based language...
volatile与synchronized的区别,锁提供了两种主要特性：互斥（mutual exclusion） 和可见性（visibility）
synchronized 测试案例，同步一个对象或者多个对象的案例均有，还有成功和失败案例的对比
我自己的博客所附带的案例源码，我的博客标题名称是"synchronized并发讲解",关注我等待跟多更新
java同步synchronized关键字用法示例
java多线程编程核心技术synchronized实例大全，同步方法，同步语句块，类锁，对象锁全都用代码来展现出来
有需要2014版本之前的Synchronized 6-Pulse Generator元器件，提供slx文件下载，直接复制过去即可使用。Matlab表示：如果您的旧版型号包含 同步6脉冲发生器模块，它们将继续工作。但是，为获得最佳性能，请在新型号...
Synchronized关键字的用法
java中synchronized的使用,java中的锁锁的到底是什么？是括号里的代码块吗？肯定不是的；
synchronized关键字在java中的重要性 以及常用的方法 还有它的详解
java语言 并发编程 ReentrantLock与synchronized区别 详解