java学习(synchronized)

synchronized关键字

作用：

1. 修饰代码块，被修饰的代码块称为同步语句块，其作用范围是{}括起来的代码，作用的对象是调用这个代码块的对象

2. 修饰非静态方法，被修饰的方法称为同步方法，其作用范围是整个方法，作用的对象是调用这个方法的对象

3. 修饰静态方法，其作用范围是整个静态方法，作用的对象是这个类所有的对象

4. 修饰类，其作用的范围是synchronized后面括起来的部分，作用的对象是这个类的所有对象

对代码块加锁

代码

public class ThreadSynchronize 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) {
ThreadSynchronize t1 = new ThreadSynchronize();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t1, "B");
ta.start();
tb.start();

}
}

结果

Asynchronized loop0
Asynchronized loop1
Asynchronized loop2
Asynchronized loop3
Asynchronized loop4
Bsynchronized loop0
Bsynchronized loop1
Bsynchronized loop2
Bsynchronized loop3
Bsynchronized loop4

由代码可以得出结论：当两个并发进程访问同一个对象的由synchronized (this)修饰地代码块时，一次只能有一个线程得到这个代码块，另一个必须等待

注意：是两个线程访问同一个对象的，同一个对象的，同一个对象的！

将main函数改为如下如下代码：

ThreadSynchronize t1 = new ThreadSynchronize();
ThreadSynchronize t2 = new ThreadSynchronize();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t2, "B");
ta.start();
tb.start();

得到结果

Asynchronized loop0
Bsynchronized loop0
Asynchronized loop1
Bsynchronized loop1
Asynchronized loop2
Asynchronized loop3
Bsynchronized loop2
Asynchronized loop4
Bsynchronized loop3
Bsynchronized loop4

也就是说，当不同线程要访问不同对象的同一个代码块时，synchronized不会起到阻塞效果

代码

public class ThreadSynchronize {
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) {
ThreadSynchronize t1 = new ThreadSynchronize();
Thread ta = new Thread(new Runnable() {
@Override
public void run() {
t1.m4t1();
}
},"ta");
Thread tb = new Thread(new Runnable() {
@Override
public void run() {
t1.m4t2();
}
},"tb");
ta.start();
tb.start();

}
}

结果

tb: 4
ta: 4
tb: 3
ta: 3
ta: 2
tb: 2
ta: 1
tb: 1
tb: 0
ta: 0

结果表明：当一个线程访问一个对象的synchronized(this) 代码块时，另一个线程可以访问该对象的非synchronized(this) 修饰的代码块(不同函数中的)

将m4t2()修改得与m4t1()相同，即都用synchronized(this)修饰后，得到结果

ta: 4
ta: 3
ta: 2
ta: 1
ta: 0
tb: 4
tb: 3
tb: 2
tb: 1
tb: 0

结果表明：当一个线程访问到了一个对象的synchronized(this)修饰的代码块时，其他所有线程对该对象的synchronized(this)修饰的代码块的访问都会被阻塞，此时称该线程获取了该对象的对象锁，使得其他线程都不能在此时访问同步代码块

对指定某个对象加锁

public class ThreadSynchronize {
public static void main(String[] args) {
Account account = new Account("zhangsan", 10000);
AccountOperator accountOperator = new AccountOperator(account);

final int THREAD_NUM = 5;
Thread[] threads = new Thread[THREAD_NUM];
for (int i = 0; i < THREAD_NUM; i++) {
threads[i] = new Thread(accountOperator, "Thread" + i);
threads[i].start();
}
}
}

class Account {
String name;
float amount;

public Account(String name, float amount) {
this.name = name;
this.amount = amount;
}

public void deposit(float amt) {
amount += amt;
try{
Thread.sleep(100);
} catch (InterruptedException e){

}
}
public void withdraw(float amt) {
amount -= amt;
try {
Thread.sleep(100);
} catch(InterruptedException e){

}
}

public float get() {
return amount;
}
}

class AccountOperator implements Runnable {
private Account account;
public AccountOperator(Account account) {
this.account = account;
}

@Override
public void run() {
// TODO Auto-generated method stub
synchronized(account){
account.deposit(500);
account.withdraw(300);
System.out.println(Thread.currentThread().getName() + " : " + account.get());
}
}

}

输出结果

Thread0 : 10200.0
Thread3 : 10400.0
Thread4 : 10600.0
Thread2 : 10800.0
Thread1 : 11000.0

在run方法里，我们用synchronized给account对象加了锁，此时，其他想要访问也对account加了锁的区域的线程将会被阻塞

修饰一个非静态方法

public synchronized void run() {
// TODO Auto-generated method stub

account.deposit(500);
account.withdraw(300);
System.out.println(Thread.currentThread().getName() + " : " + account.get());

}

表示该方法一次只能让一个对象调用，与之前一个表示方式等价

修饰静态方法

很明显，静态方法是属于类的，因此，静态方法可以保证同一个类的不同实例之间保持同步

public class ThreadSynchronize implements Runnable {
public void run() {
method();
}

public static synchronized void method(){
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "synchronized loop" + i);
}
}

public static void main(String[] args) {
ThreadSynchronize t1 = new ThreadSynchronize();
ThreadSynchronize t2 = new ThreadSynchronize();
Thread ta = new Thread(t1, "A");
Thread tb = new Thread(t2, "B");
ta.start();
tb.start();

}
}

输出结果为

Asynchronized loop0
Asynchronized loop1
Asynchronized loop2
Asynchronized loop3
Asynchronized loop4
Bsynchronized loop0
Bsynchronized loop1
Bsynchronized loop2
Bsynchronized loop3
Bsynchronized loop4

修饰一个类

很明显，修饰一个类的时候，该类的所有实例公用同一把锁

参考：http://blog.csdn.net/luoweifu/article/details/46613015