线程学习

I. Object

void notify()    
                    唤醒在此对象监视器上等待的单个线程。    
void notifyAll()    
                    唤醒在此对象监视器上等待的所有线程。    
void wait()    
                    导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。    
void wait(long timeout)    
                    导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。    
void wait(long timeout, int nanos)    
                    导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量?

1.上述方法必须在同步块或同步方法中使用

synchronized {

}

2.java的内存模型是对每一个进程有一个主内存， 每个线程有自己的内存， 他们从主内存中取数据， 然后计算， 再存入主内存中在JAVA中的Object类型中，都是带有一个内存锁的，在有线程获取该内存锁后，其它线程无法访问该内存，从而实现JAVA中简单的同步、互斥操作。

修改一个数据的过程：取数据[加锁]， 操作数据， 存数据[解锁]

JAVA中规定对非（FLOAT, LONG）的原始类型的取和存操作为原子操作。 其实就是对一个字（32位）的取，存位原始操作， 因为FLOAT, LONG为两个字节的长度， 所以其取， 存为非原子操作。 如果想把他们也变为原子操作， 可以用VOLATILE关键字来修饰

wait操作是暂停当前线程，并且释放锁，以便其他线程进入获得锁。

lock.notify();  // 唤醒另外一个进程
lock.wait(); 	// 暂时释放资源

package com.xp.thread;

public class testThread {

	private byte[] lock = new byte[0];

	public static void main(String args[]) {
		testThread mT = new testThread();
		mT.demo();
	}

	public void demo() {
		printThread a = new printThread("a");
		printThread b = new printThread("b");
		a.start();
		b.start();
	}

	class printThread extends Thread {
		public printThread(String name) {
			this.setName(name);
		}

		public void run() {
			synchronized (lock) {
				for (int i = 0; i < 100; i++) {
					if (i % 10 == 0 && 0 != i) {
						try {
							lock.notify(); 	// 唤醒另外一个进程
							lock.wait(); 	// 暂时释放资源
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(this.getName() + ": " + i);
					}
				}

				lock.notify(); 				// 唤醒另外一个进程
				System.out.println(this.getName() + ":End");
			}
		}
	}
}

Console:

a: 10
b: 10
a: 20
b: 20
a: 30
b: 30
a: 40
b: 40
a: 50
b: 50
a: 60
b: 60
a: 70
b: 70
a: 80
b: 80
a: 90
a:End
b: 90
b:End

必须先notify  再 wait

参考：
http://blog.csdn.net/weizhaozhe/article/details/3922647
http://blog.csdn.net/zyplus/article/details/6672775

II. synchronized

III.

Java多线程编程总结

volatile原理与技巧

http://kenwublog.com/the-theory-of-volatile

java 内存模型 ( java memory model )
根据Java Language Specification中的说明, jvm系统中存在一个主内存(Main Memory或Java Heap Memory)，Java中所有变量都储存在主存中，对于所有线程都是共享的。

每条线程都有自己的工作内存(Working Memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。