java高级----线程

[size=medium]程序：硬盘上可执行文件的集合；
进程是指一个程序被执行，一个程序可以产生多个进程；
线程：一个进程中包含多个线程，线程共享进程的内存空间，但每个线程又是相对独立的。线程我们认为它是可以并发进行的，即同一个进程里面可以有多个线程在同时运行，但是从真正意义上来说，不存在两个线程同时运行，这是因为CPU在任何时刻一次都只能执行一个线程，只是系统调度的时间非常快，我们肉眼察觉不到，因此认为线程可以并发进行。

创建线程的方法有三种：
1> public class A extends Thread{
}

2> public class B implements Runnable{
}

3> public class C extends Timetask{
}


启动线程的方式有：
1> A a=new A(); a.start();
2> B b=new B(); new Thread(b).start();
3> C c=new C(); Timer time=new Timer(); time.schedule(c,100,200);

要注意的是：当线程调用start()方法的时候它是处于就绪状态，被存放在CPU的等待池，等待系统的调度，只有获得CPU使用权的线程才能运行，在运行的时候线程自动调用自己的Run()方法。

线程安全性的问题：
线程同步是安全的，线程异步是不安全的。这里的同步与异步与我们现实生活中的情形是相反的。

线程同步的实现：
1> 同步代码：将要同步的代码写在一个synchronized 代码块中
如：synchronized(object o){
要同步的代码
}
2>同步方法：将一个方法用synchronized 关键字修饰

3>LinkedBlockingDeque list=new LinkedBlockingDeque();如：
package 验证01;

public class Computer {
String name;

public Computer(String name) {
super();
this.name = name;
}

@Override
public String toString() {
// TODO Auto-generated method stub
return name;
}
//===========================================================//

package 验证01;

import java.util.ArrayList;
import java.util.concurrent.LinkedBlockingDeque;

public class Produce extends Thread{
public static LinkedBlockingDeque<Computer> alist=new
LinkedBlockingDeque<Computer>(1);
int i=0;
public void run(){
while(true){
i++;
Computer com=new Computer("这是第"+i+"台，电脑");
System.out.println("生产了第"+i+"台，电脑");
try {
alist.put(com);
} catch (InterruptedException e1) {
e1.printStackTrace();
}

try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

//==============================================================//
package 验证01;

public class Consumer extends Thread{
public void run(){
while(true){

if(Produce.alist.size()>0){
Computer co;
try {
co = Produce.alist.take();
System.out.println("消费了："+co);
} catch (InterruptedException e) {
e.printStackTrace();
}

}



}

}
}
//====================================================================================//
package 验证01;

public class TestBuy {
public static void main(String[] args) {
Produce pr=new Produce();
pr.start();
Consumer co=new Consumer();
co.start();
}
}
//==================================================================//

4> Lock l=new ReentrantLock();
方法(){
l.lock();
要同步的代码
l.unlock();
}

这里要特别注意的是：在synchronized(object o)中这个o必须是同一个对象，一般情况下我们要操作哪个对象就把哪个对象用作监视器对象。一旦一个线程包含在一个同步方法中，其他线程就无法调用相同对象的同步方法，要等这个线程执行完同步方法了或碰o.wait()时它才放弃CPU，放弃锁定，调用的线程进入监视器的等待池。其他线程才有机会获得这个监视器的锁定[size=medium][/size]才能被执行。

在线程同步的过程中要特别注意死锁的问题，尽量避免多个线程依赖多个同步对象；

线程通讯：
String str="";
synchronized(str){
str.wait() ;
}
synchronized(str){
str.notify();
}

线程的暂停，停止模型
线程暂停：
sleep(1000)
wait();

线程的停止：
必须是run方法自然结束


多线程游戏需要暂停
run(){
while(是否停止){
if(是否暂停){
//逻辑代码
}
}
}
[/size]