学步园

线程：是一个程序里面不同的执行路径
进程：一个class文件，一个exe文件，静态的概念，进程的执行指的是进程里面的主线程，main方法执行了，实际上都是线程在执行
        同一个时间点上，一个cpu只能支持一个线程在执行

两种方式创建线程：1.继承thread（只能是单继承较狭隘）

                          

class Runner2 extends Thread{
	public void run() {
	}
	
}
new Runner2().start();

                         2.实现runnerable

class Runner1 implements Runnable {
	public void run() {
	}

}

new Thread(new Runner1()).start()

一些常用到的方法属性：
sleep：休眠(并不释放锁)
join:合并线程(相当于方法调用)
yield：让出小会儿给别人执行

线程的优先级

Object.wait():(让正在访问此代码块的线程等待一下，让别的线程继续运行)调用此方法时，必须锁定该对象
Object.notify():(叫醒正在访问此代码块的单个线程)

Object.notifyAll():(叫醒正在访问此代码块的所有线程)

synchronized:线程同步(锁定当前内容，同一时间只有一个线程访问它)：
      

        /**
	 *放在方法上
         */
      public synchronized void add(String name){
            num ++;
            try {Thread.sleep(1);}
            catch (InterruptedException e) {
            System.out.println(name+", 你是第"+num+"个使用timer的线程");
           }
        }
        /**
         *放在代码块中
	 */
        public void add(String name){
            synchronized (this) {
            num ++;
            try {Thread.sleep(1);}
            catch (InterruptedException e) {
            System.out.println(name+", 你是第"+num+"个使用timer的线程");
            }
            }
        }

 

死锁： 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生 了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁

        如果线程A锁住了记录1并等待记录2，而线程B锁住了记录2并等待记录1，这样两个线程就发生了死锁现象

package thread;

/**
 * 
 * @description
 *                    死锁的例子
 * @package name      
 *                    thread.DeadLock.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-8下午10:44:04
 */
public class DeadLock implements Runnable{
    int flag;
    static Object o1 = new Object();//注意是静态的，那样才是属于类独有的，不是属于对象的
    static Object o2 = new Object();
    
    public void run() {
        System.out.println("flag:" + flag);
        if(flag == 1) {
            synchronized (o1) {
                try{
                    Thread.sleep(500);
                }catch(Exception e){
                    e.printStackTrace();
                }
                
                synchronized (o2) {
                    System.out.println("  看到了此输出说明flag为1的线程完全执行了");
                }
            }
        }else{
            synchronized (o2) {
                try{
                    Thread.sleep(500);
                }catch(Exception e){
                    e.printStackTrace();
                }
                
                synchronized (o1) {
                    System.out.println(" 看到了此输出说明flag为2的线程完全执行了");
                }
            }
            
        }
        
    }
    
    public static void main(String[] args) {
        DeadLock dl1 = new DeadLock();
        dl1.flag = 1;
        DeadLock dl2 = new DeadLock();
        dl2.flag = 2;
        
        Thread t1 = new Thread(dl1);
        t1.start();
        Thread t2 = new Thread(dl2);
        t2.start();
    }
}

System.out.println(" 看到了此输出说明flag为1/2的线程完全执行了"); 始终没有执行，没有输出，出现了死锁

 

 

生产者消费者问题：

package thread;

/**
 * 
 * @description
 *                    生产者消费者问题    
 * @package name      
 *                    thread.ProducerConsumer.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-8下午09:52:23
 */
public class ProducerConsumer {
    public static void main(String[] args) {
        Basket bk = new Basket();
        Producer p = new Producer(bk);
        Consumer c = new Consumer(bk);
        new Thread(p).start();
        new Thread(c).start();
    }
}
/**
 * 
 * @description
 *                    馒头     
 * @package name      
 *                    thread.ProducerConsumer.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-8下午09:52:46
 */
class Bun {
    int id;
    public Bun(int id) {
        this.id = id;
    }
    
    public String toString() {
        return "第" + (id+1) + "个馒头";
    }
}
/**
 * 
 * @description
 *                    篓子    
 * @package name      
 *                    thread.ProducerConsumer.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-8下午09:53:00
 */
class Basket {
    Bun[] buns = new Bun[5];
    int index;
    /**
     * 生产馒头
     * @author        
     *                  lj　　
     * @since    
     *                  2012-4-8下午09:54:28
     * @param b void
     *                  返回
*/
    public synchronized void add(Bun b) {//同步是防止生产者放了馒头，但是因为某些异常，index没有来得及加加，但是实际上框子的馒头个数可能超过了10，你还想放
        while(index == buns.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("生产馒头时候的等待异常");
            }
        }
        this.notify();//不写表明已经是满的了，但不叫醒消费者，就放在那里
        buns[index] = b;
        index++;
    }
    /**
     * 消费馒头
     * @author        
     *                  lj　　
     * @since    
     *                  2012-4-8下午09:54:50
     * @return Bun
     *                  返回
*/
    public synchronized Bun get() {//同步是防止消费者拿了馒头，但是因为某些异常，indent没有来得及减减，但是实际上框子里可能没有馒头了，但是你还想拿
        while(index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("拿馒头时候的等待异常");
            }
        }
        //用if出现了异常，程序会跳出if继续执行后面的语句，而while不会
        /*if(index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }*/
        this.notify();//假设index=6，不写表明已经拿完了，但不叫醒生产者，总是空着
        index--;//前面的index指针已经加加了，但是我没有那个位置装馒头，所以取出馒头的索引得往下减(类比栈内存)
        return buns[index];
    }
}
/**
 * 
 * @description
 *                    生产者    
 * @package name      
 *                    thread.ProducerConsumer.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-8下午09:53:16
 */
class Producer implements Runnable{
    Basket bk;
    public Producer(Basket bk) {
        this.bk = bk;
    }
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            Bun b = new Bun(i);
            bk.add(b);
            System.out.println("生产了" + b);
            try {
                Thread.sleep((int)Math.random()*1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("生产异常");
            }
        }
    }
    
}
/**
 * 
 * @description
 *                    消费者       
 * @package name      
 *                    thread.ProducerConsumer.java
 * @author            
 *                    lj
 * @since              
 *                    2012-4-8下午09:53:40
 */
class Consumer implements Runnable {
    Basket bk;
    public Consumer(Basket bk) {
        this.bk = bk;
    }
    @Override
    public void run() {
        for(int i = 0; i < 10; i++) {
            Bun b = bk.get();
            try {
                Thread.sleep((int)Math.random()*1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                System.out.println("消费异常");
            }
            System.out.println("拿走了" + b);
        }
    }
    
}

 

反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，假如一个线程正在执行：synchronized void { x = 3; y = 4;}　由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了 stop()方法，即使在同步块中，它也干脆地stop了，这样就产生了不完整的残废数据。而多线程编程中最最基础的条件要保证数据的完整性，所以请忘记线程的stop方法，以后我们再也不要说“停止线程”了。而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果 很难检查出真正的问题所在。

suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此 时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就 会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用 wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。