JAVA 线程中的synchronized关键字的使用

synchronized关键字的作用域有二种：
- 是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
- 是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){}，它的作用域是当前对象；
synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。
上一个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
以上规则对其它对象锁同样适用.

synchronized锁住的是括号里的对象，而不是代码。对于非static的synchronized方法，锁的就是对象本身也就是this。

例子：

public class TestAccount {
public static void main(String[] args) {
//模拟两个人来进行取款操作
        Account a=new Account();
        Thread t=new Thread(a);
        Thread t1=new Thread(a);
        t.setName("张三");
        t1.setName("李四");
        t.start();
        t1.start();
    }
}
class Account implements Runnable{
double balance=1000;//取款的金额 
    Object o=new Object();
    @Override
//方法锁
// public synchronized void run() {
public void run() {
//锁 ：一个任意对象,必须保证 所有的线程都使用同一把锁 
        synchronized (this) {
// TODO Auto-generated method stub
if (balance > 0) {
//有了程序执行的延迟 
try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
// TODO Auto-generated catch block
                    e.printStackTrace();
                }
                balance -= 1000;
                System.out.println(Thread.currentThread().getName()
                        + "取款后，金额为：" + balance);
            } else {
                System.out.println("余额不足");
            }
        }
    }

}

输出结果：

李四取款后，金额为：0.0
余额不足

例子2：


public class TestAccount {
public static void main(String[] args) {
//模拟两个人来进行取款操作
        Account1 zhangsan = new Account1();
        Account1 lisi = new Account1();
        zhangsan.setName("张三");
        lisi.setName("李四");
        zhangsan.start();
        lisi.start();
    }
}

class Account1 extends Thread {

private static double balance = 1000;

    @Override
public void run() {
        synchronized (this) {
if (balance > 0) {
try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance -= 2000;
                System.out.println(Thread.currentThread().getName() + "取款2000");
            } else {
                System.out.println("存款不足!");
            }
        }
    }
}

输出结果：

张三取款2000
存款取款2000

解决方法: 使用synchronized(xxx.class)实现全局锁的效果。

public class TestAccount {
public static void main(String[] args) {
//模拟两个人来进行取款操作
        Account1 zhangsan = new Account1();
        Account1 lisi = new Account1();
        zhangsan.setName("张三");
        lisi.setName("李四");
        zhangsan.start();
        lisi.start();
    }
}

class Account1 extends Thread {

private static double balance = 1000;

    @Override
public void run() {
        synchronized (Account1.class) {
if (balance > 0) {
try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance -= 2000;
                System.out.println(Thread.currentThread().getName() + "取款2000");
            } else {
                System.out.println("存款不足!");
            }
        }
    }
}

输出结果

张三取款2000
存款不足!

秒客网

JAVA 线程中的synchronized关键字的使用

相关文章