synchronized简单⽰例⼀、synchronized应⽤的简单⽰例
下⾯两段代码⽰例，分别⽤同步块，同步⽅法完成两个线程共同操作的计数器，计数到10。package concurrency;
public class TwoThreadCounter {
public static volatile boolean goon = fal;
public static int nums = 0;
public static void main(String[] args) {
Thread counter1 = new Thread(new Runnable() {winrar激活
@Override
public void run() {
while(goon){
synchronized (TwoThreadCounter.class) {
nums++;
System.out.println(Thread.currentThread().getName() + "\t" + nums);
if(nums == 10) {
goon = fal;
蓝铃花的花语ifyAll();
}el{
己亥杂诗的意思
try {
ifyAll();
TwoThreadCounter.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
蜜糖小公主}, "counter1");
Thread counter2 = new Thread(new Runnable() {
@Override
public void run() {
while(goon) {
synchronized (TwoThreadCounter.class) {
nums++;
System.out.println(Thread.currentThread().getName() + "\t" + nums);
if(nums == 10) {
goon = fal;
ifyAll();
}el{
try {
ifyAll();
TwoThreadCounter.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}, "counter2");
goon = true;
counter1.start();
counter2.start();
counter2.start();
try {
孙子counter1.join();
counter2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
看下输出结果：
counter1 1
counter2 2
counter1 3
counter2 4
counter1 5
counter2 6
counter1 7
counter2 8
counter1 9
counter2 10
sysnchronized也可以⽤于修饰⽅法，普通⽅法和静态⽅法都可以，我们现在⽤普通同步⽅法改写上⾯的代码，因为静态⽅法术语类对象，⽽普通⽅法属于类的实例，所以如果想⽤sysnchronized修饰普通⽅法来实现功能，要在有⼀个实例，代码如下：
import urrent.atomic.AtomicBoolean;
public class TwoThreadCounterSynNormalMethod {
public static Integer counter = 0;
public static AtomicBoolean goon = new AtomicBoolean(fal);
public TwoThreadCounterSynNormalMethod() {}
向北飞
public synchronized void counterIncreace(){
counter ++;
System.out.println(Thread.currentThread().getName() + "\t" + counter);
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
幼儿学加减法窍门
}
public static void main(String[] args) {
TwoThreadCounterSynNormalMethod ttcsnm = new TwoThreadCounterSynNormalMethod();
Thread counter1 = new Thread(new Runnable() {
@Override
public void run() {
()){
if(counter == 10) {
goon.t(fal);
}
}
}
}, "counter1");
Thread counter2 = new Thread(new Runnable() {
@Override
public void run() {
()) {
if(counter == 10) {
goon.t(fal);
}
}
}
}, "counter2");
goon.t(true);
boolean hasStart = fal;
()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (ttcsnm) {// 这⾥很重要，因为对普通⽅法使⽤synchronized关键字修饰，其实是把调⽤该⽅法的实例作为了锁对象 ifyAll(); //所以当需要唤醒时，是调⽤的iffyAll();提手旁加吉加页念什么
}
}
}
}
输出结果是⼀样的。
⼆、synchronized关键字的使⽤
上⾯通过类⽐已经说明了synchronized实现同步时涉及到的⽅法以及含义，涉及到的⼏个⽅法分别
为：obj.wait()、ify()、ifyAll()，这⼏个⽅法必须在同步块中调⽤，synchronized关键字只要作⽤就是指定谁是锁，在Java
中每个对象都可以作为锁。
主要有三种形式：
对于普通同步⽅法，锁是当前的实例对象。在上⾯的第⼆个代码⽰例中，⽤synchronized修饰普通⽅法，调⽤这个⽅法的实例是
ttcsnm，那么要进⼊这个⽅法，就要取得实例对象ttcsnm对应的锁，所以我在唤醒时，需要调⽤ttcsnm
对于静态同步⽅法，锁是当前类的Class对象。可以类⽐普通同步⽅法，普通同步⽅法属于实例，所以要进⼊同步⽅法，需要获得实例对应的锁，⽽静态⽅法属于类，调⽤时也通过类名来调⽤，所以⽤synchronized关键字修饰静态⽅法，那么要访问该⽅法，需要拿到类对象对应的锁。
对于同步块，synchronized后⾯括号⾥的对象就是锁，如上⾯第⼀个代码⽰例所⽰，⽤的是类对象TwoThreadCounter.class作为
锁，要访问同步块中的内容就必须拿到这个锁。
接下来分析实现计数器功能的代码。
3.1使⽤同步代码块
第⼀个⽰例中，使⽤的是同步块，同步块的书写遵循以下格式：
synchronized (obj) {
// 执⾏内容
}
obj即指定的锁，任何对象均可以，执⾏内容即⽤户要完成的业务逻辑，再回到代码⽰例
synchronized (TwoThreadCounter.class) { //此处指定TwoThreadCouter的类对象为锁
counter++; //这⾥是真正要完成的功能，即每次让计数器的值增加1
System.out.println(Thread.currentThread().getName() + "\t" + counter);
if(counter == 10) { // 判断如果当前技术器增加到10，那就停⽌，让线程停⽌的⽅式，此处选择使⽤atomicBooelan类来作为⼀个标志，如果其值为fal，线程看到后就 goon.t(fal);
}el{
try {
TwoThreadCounter.class.wait(); // 这⾥很关键，当⼀个线程对计数器进⾏加1操作后，如果没有累加到10，就需要另外⼀个线程继续加
} catch (InterruptedException e) { // 所以需要让当前线程放弃锁，根据上⾯分析的，想剥夺锁，必须在同步块内部，调⽤obj.wait()⽅法
e.printStackTrace(); // 这个⽅法会让当前线程在此⽅法等待（不是阻塞），直到线程死亡或被唤醒才能从该⽅法返回
}
}
} // 当线程成功执⾏完同步代码块，出这个"｝"时，会主动调⽤notifyall()⽅法。
两个线程的同步块内容是⼀样的，当前线程拿到锁，对计数器执⾏加⼀操作，然后判断是否结束，如果没结束，就需要放弃锁，原地等待，
让另外⼀个线程有机会获得锁，并执⾏相同的功能。另外⼀个线程执⾏相同的操作后，也在wait()⽅法处等待，所以此时需要另外在外⾯唤
醒
()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (TwoThreadCounter.class) {
ify();
}
}
这段代码由主线程来执⾏，完成对两个线程的控制，当执⾏计数器加⼀操作的两个线程均运⾏到TwoThreadCounter.class.wait() ⽅法时，两个线程放弃锁，同时进⼊等待状态，所以在主线中，main线程可以顺利获得锁，进⼊同步块
synchronized (TwoThreadCounter.class) {
ify();
}// 当主线程执⾏完同步块时，才会释放锁，调⽤notify⽅法并不释放锁
在同步块中，调⽤ify()，此时会唤醒等待队列中的第⼀个线程，允许该线程拥有获得锁的机会，但此时锁依然在主线程⼿⾥，只有当主线程退出同步块时，才会把锁释放掉，被唤醒的线程才能获得锁。
这样，处于排队的线程可重新获得锁，从wait()⽅法返回，继续执⾏，再判断是否结束了，如果没有结束，重新尝试获得锁。
3.1使⽤同步⽅法
对于同步⽅法，注意锁对象是调⽤该⽅法的实例即可，所以在唤醒时，要⽤实例来调⽤notifyAll（）⽅法。
()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (ttcsnm) {// 这⾥很重要，因为对普通⽅法使⽤synchronized关键字修饰，其实是把调⽤该⽅法的实例作为了锁对象
}
}
