JAVA多线程

public class TT implements Runnable {
    int b = 100;
    
    public synchronized void m1() throws Exception{
        //Thread.sleep(2000);
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }
    
    public  void m2() throws Exception {
        Thread.sleep(2000);
        b = 2000;
    }
    
    public void run() {
        try {
            m1();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) throws Exception {
        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        tt.m2();
    }
}

package javaee.net.cn.thread;
public class ProducerConsumer {
    //这里用是三个生产者线程和一个消费者线程来测试
    //如果想要把生产者生产的全部消费完 消费者的run方法执行的次数就需要时生产者的三倍 (i<6)
    public static void main(String[] args) {
        SyncStack ss = new SyncStack();
        Producer p = new Producer(ss);
        Consumer c = new Consumer(ss);
        //启动线程是调用start()方法，如果直接调用run方法就是普通的方法调用，不是异步的。
        new Thread(p).start();
        new Thread(p).start();
        new Thread(p).start();
        new Thread(c).start();
    }
}
//这是声明一个对象 用来放进栈里面
class WoTou {
    int id; 
    WoTou(int id) {
        this.id = id;
    }
    public String toString() {
        return "WoTou : " + id;
    }
}
/**
 * 数据结构中 栈
 * 有push和pop方法 
 */
class SyncStack {
    int index = 0;
    WoTou[] arrWT = new WoTou[6];
    //因为arrWT 和index是成员变量，所以需要对这两个方法加锁。 加锁是锁住当前对象，他里面的成员变量自然也就锁定了
    public synchronized void push(WoTou wt) {
        //须用while 而不是if 因为如果栈满了 需要一直等待
        while(index == arrWT.length) { 
            try {
                //栈满了时 需要停止住
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //wait不同于sleep 不需要指定睡眠的时间， 但需要手动唤醒. 当index不等arrWT.length 表示栈现在不是满的可以进行push 于是手动唤醒线程
        this.notifyAll();    
        //如果不加锁 arrWT和index因为多线程同步 导致新加的窝头和指针不匹配
        //先把当前指针 执行新加的窝头
        arrWT[index] = wt;
        //然后把指针加1
        index ++; 
    }
    //pop操作和push操作刚好相反
    public synchronized WoTou pop() {
        while(index == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notifyAll();
        index--;
        return arrWT[index];
    }
}
/**
 * 定义一个生产者 每生产一个对象 睡眠200ms
 */
class Producer implements Runnable {
    SyncStack ss = null;
    Producer(SyncStack ss) {
        this.ss = ss;
    }
    @Override
    public void run() {
        for(int i=0; i<2; i++) {
            WoTou wt = new WoTou(i);
            ss.push(wt);
            System.out.println("生产了：" + wt);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }            
        }
    }
}
/**
 * 定义一个消费者 
 */
class Consumer implements Runnable {
    SyncStack ss = null;
    Consumer(SyncStack ss) {
        this.ss = ss;
    }
    @Override
    public void run() {
        for(int i=0; i<6; i++) {
            WoTou wt = ss.pop();
            System.out.println("消费了: " + wt);
            try {
                //每消费一个对象 睡眠200ms  可以在console控制台 慢慢的看到线程的调度执行
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }            
        }
    }
}