线程问题3（synchronized,wait,notify,notifyAll,类锁,对象锁）

时间：2015-04-08 23:29:23 阅读：273 评论：0 收藏：0 [点我收藏+]

标签：

/**
* 知识一:
* 实现线程，有两种方法，一种是继承Thread类，一种是实现Runnable接口。
* 本文推荐实现Runnable接口的方法。
* 1.把需要共享的数据(可以是静态的，非静态的变量了)放在一个实现Runnable
* 接口的类里面，然后把这个类的实例传给多个Thread的构造方法。这样，新创建
* 的多个Thread，都共同拥有一个Runnable实例，共享同一份数据。
* 2.如果采用继承Thread类的方法，就只好使用static静态成员了。
* 如果共享的数据比较多，就需要大量的static静态成员，令程序数据结构混乱，
* 难以扩展。这种情况应该尽量避免。
*
* 知识二:
* JAVA的进程同步是通过synchronized()来实现的，需要说明的是，
* JAVA的synchronized()方法类似于操作系统概念中的互斥内存块，在JAVA中的Object类型中，
* 都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。
* 明白这个原理，就能理解为什么synchronized(this)与synchronized(static XXX)的区别了，
* synchronized就是针对内存区块申请内存锁，this关键字代表类的一个对象，
* 所以其内存锁是针对相同对象的互斥操作，而static成员属于类专有，其内存空间为该类所有成员共有，
* 这就导致synchronized()对static成员加锁，相当于对类加锁，也就是在该类的所有成员间实现互斥，
* 在同一时间只有一个线程可访问该类的实例。如果只是简单的想要实现在JAVA中的线程互斥，明白这些基本就已经够了。
* 但如果需要在线程间相互唤醒的话就需要借助Object.wait(), Object.nofity()了。
*
* Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,
* 与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是
* Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。
* 从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。
* 直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。
* 相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，
* 并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，
* JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。
* 这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，
* 释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
*
* 注意:
* 1) 必须在synchronized里面才可以使用notify,notifyAll,wait方法；
* 2) synchronized必须是以一个对象或者一个类做为锁资源，一旦某个线程进入这个sychronized区段，
* 那么synchronized(这个锁资源)的所有代码地方其他多个线程都不可以进入。
*
* 知识三:
* 1、synchronized关键字的作用域有二种：
* 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法
* （如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不
* 能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。
* 也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
* 2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。
* 它可以对类的所有对象实例起作用。
* 2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
* 用法是: synchronized(this){区块}，它的作用域是当前对象；
* 3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，
* 而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
*/
public class QueueThreadWaitNotify implements Runnable {

private final Object lock = new Object();

public static void main(String[] args) throws InterruptedException {

QueueThreadWaitNotify a = new QueueThreadWaitNotify();

//很多个线程因为要访问lock对象阻塞，
//排成队列，等待资源的释放。

for (int i = 1; i <=16; i++) {
new Thread(a, String.valueOf(i)).start();
}
//先将main主线程休眠一段时间
Thread.sleep(5000);

//开启对阻塞队列的唤醒。
new Thread(a, "WakeUp").start();

}

public void run() {
String name = Thread.currentThread().getName();

if (name.equals("WakeUp")) {
System.out.println("WakeUp get object before ---" + name);
synchronized (lock) {
System.out.println("WakeUp get object after ---" + name);
System.out.println("WakeUp get object" + name);

/**
* notifyAll()与notify()的区别:
* notifyAll是通知多个阻塞线程
* notify是通知一个阻塞线程
* notifyAll()使用方法：
*/
lock.notifyAll();

/**
* notify的使用方法：
* 如果将上面的notifyAll代码注释了，
* 使用下面的notify的话，会导致只有一个线程唤醒，其他受阻的线程还阻。
*/
//lock.notify();

System.out.println("WakeUp give up object" + name);
}

} else {
System.out.println("give up object before ---" + name);
synchronized (lock) {
System.out.println("give up object after ---" + name);
try {
System.out.println(name + " give up object ---" + name);
lock.wait();
System.out.println(name + " get lock object again ---" + name);

/**
* notify的使用方法：
* 必须加上这句话，才可以在上面使用notify()的时候，防止其他线程受阻。
*/
//lock.notify();
} catch (InterruptedException e) {

e.printStackTrace();
}
System.out.println(name + " get lock object end. ---" + name);
}
}
}
}

标签：

原文地址：http://blog.csdn.net/chinayuan/article/details/44947561

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行