多线程

//因为不是类中所有代码都要被线程执行, 为了区分哪些代码需要被执行
//java提供了Thread类中的run()方法用来包含那些被线程执行的代码
public class SimpleThread extends Thread {
    public SimpleThread(String name) {        // 参数为线程名称
        setName(name);
    }
    public void run() {        // 覆盖run()方法
        int i = 0;
        while (i++ < 5) {         // 循环5次
            try {
                System.out.println(getName() + "执行步骤" + i);
                Thread.sleep(1000);     // 休眠1秒
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        SimpleThread thread1 = new SimpleThread("线程1");     // 创建线程1
        SimpleThread thread2 = new SimpleThread("线程2");     // 创建线程2
        thread1.start();                                     // 启动线程1
        thread2.start();                                    // 启动线程2
    }
}

/*
 * Runnable接口中只有一个run()方法，它非Thread类子类的类提供的一种激活方式。一个类实现Runnable接口后，并不代表
 * 该类是一个“线程”类，不能直接运行，必须通过Thread实例才能创建并运行线程。
 */
public class SimpleRunnable implements Runnable {
    public void run() { // 覆盖run()方法
        int i = 15;
        while (i-- >= 1) { // 循环15次
            try {
                System.out.print("*");
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        //通过Thread实例运行线程
        Thread thread1 = new Thread(new SimpleRunnable(),"线程1"); // 创建线程1
        thread1.start(); // 启动线程1
    }
}

public class SyncThread extends Thread {
    private char cha;
    public SyncThread(char cha) {                         // 构造函数
        this.cha = cha;
    }
    public void run() {
        PrintClass.printch(cha);                         // 调用同步方法
        System.out.println();
    }
    public static void main(String[] args) {
        SyncThread t1 = new SyncThread(‘A‘);             // 创建线程A
        SyncThread t2 = new SyncThread(‘B‘);             // 创建线程B
        t1.start();                                     // 启动线程A
        t2.start();                                     // 启动线程B
    }
}
class PrintClass {
    //同步方法的使用：在方法上加synchronized
    public static synchronized void printch(char cha) { // 同步方法
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);                    // 打印一个字符休息1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.print(cha);
        }
    }
}

public class SyncThread extends Thread {
    private String cha;
    public SyncThread(String cha) {                 // 构造函数
        this.cha = cha;
    }
    public void run() {
        PrintClass.printch(cha);                    // 调用同步方法
    }
    public static void main(String[] args) {
        SyncThread t1 = new SyncThread("线程A");     // 创建线程A
        SyncThread t2 = new SyncThread("线程B");     // 创建线程B
        t1.start();                                 // 启动线程A
        t2.start();                                 // 启动线程B
    }
}
class PrintClass {
    static Object printer = new Object();             // 实例化Object对象
    public static void printch(String cha) {         // 同步方法
        synchronized (printer) {                     // 同步代码块:同步代码块则在方法内部加
            for (int i = 1; i < 5; i++) {
                System.out.println(cha + " ");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

//进水
public class ThreadA extends Thread {
    Water water;
    public ThreadA(Water waterArg) {
        water = waterArg;
    }
    public void run() {
        System.out.println("开始进水.....");
        for (int i = 1; i <= 5; i++) {                // 循环5次
            try {
                Thread.sleep(1000);                // 休眠1秒，模拟1分钟的时间
                System.out.println(i + "分钟");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        water.setWater(true);                        // 设置水塘有水状态
        System.out.println("进水完毕，水塘水满。");
        synchronized (water) {
            water.notify();                         // 线程调用notify()方法
        }
    }
}

/*
notify()方法表示，
当前的线程已经放弃对资源的占有， 
通知等待的线程来获得对资源的占有权，
但是只有一个线程能够从wait状态中恢复，
然后继续运行wait()后面的语句；
只会唤醒等待该锁的其中一个线程。
notifyAll()方法表示，
当前的线程已经放弃对资源的占有，
 通知所有的等待线程从wait()方法后的语句开始运行;
  唤醒等待该锁的所有线程。
*/

public class ThreadB extends Thread {
    Water water;
    public ThreadB(Water waterArg) {
        water = waterArg;
    }
    public void run() {
        System.out.println("启动排水");
        if (water.isEmpty()) {                            // 如果水塘无水
            synchronized (water) {                        // 同步代码块
                try {
                    System.out.println("水塘无水，排水等待中.....");
                    water.wait();                            // 使线程处于等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("开始排水.....");
        for (int i = 5; i >= 1; i--) {                        // 循环5侧
            try {
                Thread.sleep(1000);                         // 休眠1秒，模拟1分钟
                System.out.println(i + "分钟");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        water.setWater(false);                        // 设置水塘无水状态
        System.out.println("排水完毕。");
    }
}

public class Water {
    boolean water = false;                            // 反应水塘状态的变量
    public boolean isEmpty() {                            // 判断水塘是否无水的方法
        return water ? false : true;
    }
    public void setWater(boolean haveWater) {            // 更改水塘状态的方法
        this.water = haveWater;
    }
    public static void main(String[] args) {
        Water water=new Water();                        // 创建水塘对象
        ThreadA threadA = new ThreadA(water);            // 创建进水线程
        ThreadB threadB = new ThreadB(water);            // 创建排水线程
        threadB.start();                                // 启动排水线程
        threadA.start();                                // 启动进水线程
    }
}

public class Consumer extends Thread {
  private Share shared;//共享资源区
  private int number;
  public Consumer(Share s, int number) {
    shared=s;
    this.number=number;
  }
 public void run() {
    int value = 0;
    for (int i=0; i<10; i++) {
      value=shared.get();//从共享区消费数字
      System.out.println("消费者"+this.number+"  得到的数据为："+value);
    }
  }
}

public class Producer extends Thread {
  private Share shared;//共享资源区
  private int number;
  public Producer(Share s, int number) {
    shared=s;
    this.number=number;
  }
 public void run() {
    for (int i=0; i<10; i++) {
      shared.put(i);//生产数字放入共享区
      System.out.println("生产者"+this.number+"  输出的数据为："+i);
      try {
        sleep((int)(Math.random() * 100));//休眠随机时间
      } catch (InterruptedException e) {}
    }
  }
}

//(1)
public class Share {
  private int contents;
  public int get(){//从共享区取数字
    return contents;
  }
  public void put(int value){//放入共享区
    contents=value;
  }
}

public class PCTest {
  public static void main(String[] args) {
    Share s=new Share();
    Producer p=new Producer(s,1);
    Consumer c=new Consumer(s,1);
    p.start();
    c.start();
  }
}

public class Share {
    private int contents;
    // 等待唤醒机制的使用
    private boolean available = false;

    public synchronized int get() {
    while (available==false) {
      try {
        wait();
      } catch (InterruptedException e) {}
    available=true;
    notifyAll();
    }
    return contents;
    }
    public synchronized void put(int value) {
        while (available == true) {
            try {
                wait();
            } catch (InterruptedException e) {
            }
        }
        contents = value;
        available =false;
        notifyAll();
    }
}
/*
*等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
wait：告诉当前线程放弃执行权，并放弃监视器（锁）并进入阻塞状态，直到其他线程持有获得执行权，并持有了相同的监视器（锁）并调用notify为止。
notify：唤醒持有同一个监视器（锁）中调用wait的第一个线程，被唤醒的线程是进入了可运行状态。等待cpu执行权。
notifyAll：唤醒持有同一监视器中调用wait的所有的线程。

*
*/