java 多线程 心得 体会

点解 java 多线程..

先说相关的名词:
Thread Runable wait notify notifyAll join lock synchronized util.concurrent volatile Daemon

名词解释:

守护线程 ,又称精灵线程(Daemon Thread)
非守护线程，又称用户线程（User Thread）


用个比较通俗的比如，任何一个守护线程都是整个JVM中所有非守护线程的保姆：只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。

线程肯定都是在一个进程内,共享一个进程的内存.我对一个进程简单理解就是"一个main启动的还没有执行完毕的暂时状态"
jvm 内存模型 . 多线程并发 保证 可见性 有序性.

对象锁 类锁 方法锁 代码块锁 整体锁

synchronized (this) 当前对象为锁

在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制

理论上，每个对象都可以做为锁，但一个对象做为锁时，应该被多个线程共享，这样才显得有意义，在并发环境下，一个没有共享的对象作为锁是没有意义的(结合单例模式)

生产者/消费者模式其实是一种很经典的线程同步模型，很多时候，并不是光保证多个线程对某共享资源操作的互斥性就够了，往往多个线程之间都是有协作的。

wait方法是从Object来的，所以任意对象都有这个方法

如果一个线程获得了锁lock，进入了同步块，执行lock.wait()，那么这个线程会进入到lock的阻塞队列。如果调用lock.notify()则会通知阻塞队列的某个线程进入就绪队列。

volatile是java提供的一种同步手段，只不过它是轻量级的同步，为什么这么说，因为volatile只能保证多线程的内存可见性，不能保证多线程的执行有序性。而最彻底的同步要保证有序性和可见性，例如synchronized。任何被volatile修饰的变量，都不拷贝副本到工作内存，任何修改都及时写在主存。

volatile只保证了可见性，所以Volatile适合直接赋值的场景

join 联合 等所有线程执行完毕以后再往下走.

以下是一个多线程生产消费的例子

public class PlateFactory {
private static Plate plate;
public static Plate createPlate() {
if (plate == null) {
plate = new Plate();
}
return plate;
}
}


import java.util.ArrayList;
import java.util.List;

public class Plate {
public List eggs = new ArrayList();

public synchronized Object getEgg() {
if (eggs.size() == 0) {
try {
System.out.println("取线程判断集合为空,等待");
wait();
} catch (InterruptedException e) {
}
}
Object egg = eggs.get(0);
eggs.clear();// 清空盘子
notify();// 唤醒阻塞队列的某线程到就绪队列
return egg;
}

public synchronized void putEgg(Object egg) {
if (eggs.size() > 0) {
try {
System.out.println("放线程判断集合size大于0,等待");
wait();
} catch (InterruptedException e) {
}
}
eggs.add(egg);// 往盘子里放鸡蛋
notify();// 唤醒阻塞队列的某线程到就绪队列
}
}

public class client {
public static void main(String[] args) {
Plate plate =PlateFactory.createPlate();
System.out.println("放客户端盘子对象"+plate);
// for (int i = 0; i < 10; i++) {
Thread b =new Thread(new putThread(plate));
b.start();
Thread a =new Thread(new getThread(plate));
a.start();
// }

}

}
class putThread implements Runnable {
Plate plate;
public putThread(Plate plate){
this.plate = plate;
}
public void run() {
while(true){

Object obj = new Object();
System.out.println("放入"+obj);
plate.putEgg(obj);
try {
Thread.sleep(20000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}


}
class getThread implements Runnable {
Plate plate ;
public getThread(Plate plate){
this.plate = plate;
}
public void run() {
while(true){
//System.out.println("取出线程开始");
Object obj = plate.getEgg();
System.out.println("取出"+obj);
try {
Thread.sleep(20000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}