来源玉

来源：互联网发布：win10改不了mac地址编辑：程序博客网时间：2024/04/27 18:32

[java] view plaincopyprint?

package com.jadyer.thread.sync;
/**
* Synchronized Static Method Test
* @see 说明：如果某个synchronized方法是static的
* @see 那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是该方法所在的对象所对应的Class对象
* @see 因为Java中无论一个类有多少个对象，这些对象都会对应唯一的一个Class对象
* @see 因此当线程分别访问同一个类的两个对象的两个static的synchronized方法时，它们的执行顺序也是顺序执行的
* @see 即一个线程先执行一个static的synchronized方法，执行完毕后，另一个线程才开始执行另一个static的synchronized方法
* @see 总结：重点在于判断synchronized锁的是谁。如果该方法是静态的，则锁Class对象，否则锁的就是当前对象
* @author 宏宇
* @create Feb 21, 2012 5:29:39 PM
*/
public class SynchronizedStaticTest {
public static void main(String[] args) {
Bank bank = new Bank();
Thread tt11 = new Thread(new ThreadRMB(bank));
Thread tt22 = new Thread(new ThreadDollar(bank));
tt11.start();
tt22.start();
}
}
class ThreadRMB implements Runnable{
private Bank bank;
public ThreadRMB(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.getRMB();
}
}
class ThreadDollar implements Runnable{
private Bank bank;
public ThreadDollar(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.getDollar();
}
}
class Bank{
//如要验证synchronized锁同一个类的对象，和锁它的Class对象的区别
//可去掉static关键字，再查看控制台打印，即public synchronized void getRMB()
public synchronized static void getRMB(){
for(int i=0; i<20; i++){
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
public synchronized static void getDollar(){
for(int i=0; i<20; i++){
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}

package com.jadyer.thread.sync;
/**
* Synchronized Block Test
* @author 宏宇
* @create Feb 21, 2012 5:29:39 PM
*/
public class SynchronizedBlockTest {
public static void main(String[] args) {
Bank bank = new Bank();
Thread tt11 = new Thread(new ThreadRMB(bank));
//如果要验证synchronized(this)锁的是当前类的对象，而非当前类的Class对象
//则可取消注释该行代码，再观察控制台打印效果。效果应该是两个线程并发执行的输出
//bank = new Bank();
Thread tt22 = new Thread(new ThreadDollar(bank));
tt11.start();
tt22.start();
}
}
class ThreadRMB implements Runnable{
private Bank bank;
public ThreadRMB(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.getRMB();
}
}
class ThreadDollar implements Runnable{
private Bank bank;
public ThreadDollar(Bank bank){
this.bank = bank;
}
@Override
public void run() {
bank.getDollar();
}
}
/**
* Bank
* @see 说明：synchronized块的写法：synchronized(object){//TODO...}，它表示线程在执行的时候，会对object对象上锁
* @see 通常会把java.lang.Object对象传进来，事实上这里可以传进来任何的对象
* @see 因为它是一个没有实际作用的对象，其仅仅起到锁的作用，就像一个标识一样
* @see 作用：它表示，如果线程能够进入到这里，即执行到这里，那么，就将object对象锁上
* @see 如果另一个线程也执行到这里，发现object对象已上锁，则会等待其解锁后，才会去执行synchronized块里面的代码
* @see 补充：synchronized(this)表示对当前类的对象上锁。注意，它锁的不是当前类的Class对象
* @see synchronized(Bank.class)表示对当前类的Class对象上锁
* @author 宏宇
* @create Feb 22, 2012 2:29:16 AM
*/
class Bank{
private Object obj11 = new Object();
private Object obj22 = new Object();
public void getRMB(){
//synchronized(obj11){
synchronized (Bank.class) {
for(int i=0; i<20; i++){
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
public void getDollar(){
//synchronized(obj11){
//synchronized(obj22){
synchronized (this) {
for(int i=0; i<20; i++){
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}