public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread1 mt = new MyThread1();
        //4.通过此对象调用start()方法
        mt.start(); //主线程使用mt对象调用了start方法，启动新线程。
        // start方法能够使线程执行，JVM调用这个线程的run方法

        //这里是主线程运行
        //同时运行两个线程，输出顺序就不确定，每个线程的输出也可能交叉
        for( int i = 0; i<100;i++){
            if(i % 2 != 0)
                System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
// 1.创建一个继承于Thread类的子类
class MyThread1 extends Thread{
    //2.重写Thread的run()
    @Override
    public void run() {
        for(int i = 0; i<100;i++){
            if(i % 2 == 0)
                System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) {
        MyThread2 mt = new MyThread2();
        Thread t1 = new Thread(mt,"Thread-1");
        Thread t2 = new Thread(mt,"Thread-2");
        //启动多个线程，只需要新建Thread对象，两个线程共享Runnable实现类对象
        t1.start();
        t2.start();
    }
}
class MyThread2 implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i< 100; i++)
            System.out.println(Thread.currentThread().getName());
    }
}

public class ThreadThree {
    public static void main(String[] args) {
        //创建实现类的对象
        NumThread numThread = new NumThread(); 
        //创建FutureTask类对象，将实现类对象作为参数
        FutureTask futureTask = new FutureTask(numThread); 
        //创建Thread类对象，将futureTask作为Runnable被线程执行
        new Thread(futureTask).start();  

        //FutureTask作为Future得到Callable的返回值
        try {//get的返回值即numThread重写的call的返回值
            Object num = futureTask.get();  
            System.out.println(num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
class NumThread implements Callable{ //实现Callable接口，并重写call方法
    //call()函数有返回值，且能够抛出异常
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

public class ThreadPool {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //ThreadPoolExecutor类实现了ExecutorService接口
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        //通过service1，可以设置线程池的属性...
        service1.setMaximumPoolSize(15);

        //2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumThreadFour()); //适合于Runnable,分配线程1
        service.execute(new NumThreadFour2()); //适合于Runnable，分配线程2
        service.submit(new FutureTask(new NumThreadFour3())); //适合于Callable，分配线程3
        //3.关闭线程池
        service.shutdown();
    }
}
class NumThreadFour implements Runnable {...}
class NumThreadFour2 implements Runnable {...}
class NumThreadFour3 implements Callable {...}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w2 = new Window2();
        //创建三个线程，即三个窗口
        Thread t1 = new Thread(w2,"窗口1");
        Thread t2 = new Thread(w2,"窗口2");
        Thread t3 = new Thread(w2,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window2 implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){
            if(ticket > 0){
                System.out.println(Thread.currentThread().getName()+"票号为:"+ticket);
                ticket--;
            }else break;
        }
    }
}
/*
三个线程共享100张票，在其中一个窗口操作的同时，其他线程参与进来，导致票数出现异常
以下是部分执行结果：
窗口2票号为:23
窗口2票号为:7
窗口2票号为:6
窗口1票号为:8
窗口3票号为:19
窗口1票号为:4
窗口1票号为:2
窗口2票号为:5
窗口1票号为:1
窗口3票号为:3
*/

//格式：
synchronized(同步监视器){
    //需要被同步的代码
}
//具体使用：
public class TicketSell {
    public static void main(String[] args) {
        Window w = new Window();
        //创建三个线程，即三个窗口
        Thread t1 = new Thread(w, "窗口1");
        Thread t2 = new Thread(w, "窗口2");
        Thread t3 = new Thread(w, "窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}

class Window implements Runnable {
    private int ticket = 100;
    Object obj = new Object(); //同步监视器(同步锁)
    @Override
    public void run() {
        while (true) {
            //synchronized (this){ //也可以使用当前对象
            //synchronized (Window.class){  //当前类也可以作为同步锁
            synchronized (obj) { //以下为同步代码
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + 
                                       "票号为:" + ticket);
                    ticket--;
                } else break;
            }
        }
    }
}

//格式：
权限修饰符 synchronized 返回值类型 方法名(参数){
    //操作共享数据的代码
}

//具体使用：
class Window3 implements Runnable {
    private int ticket = 100;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }
	//同步方法。非静态方法默认的同步监视器是this
    private synchronized void show() {
        if (ticket > 0) {
            System.out.println(Thread.currentThread().getName() + "票号为:" + ticket);
            ticket--;
        }
    }
}

//首先需要声明ReentrantLock对象
//然后调用lock方法加锁
//最后调用unlock方法释放锁
class Window implements Runnable {
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock(); //步骤一
    @Override
    public void run() {
        while (true) {
            lock.lock(); //步骤二，加锁
            try {
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() 
                                       + ":" + ticket);
                    ticket--;
                } else break;
            } finally {
                lock.unlock(); //步骤三，解锁
            }
        }
    }
}

public class DeadLock {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();
        new Thread() {//Thread的匿名实现类
            @Override
            public void run() {
                synchronized (s1) {
                    s2.append("a"); //持有同步锁 s1，等待s2被释放
                    System.out.println(getName() + ":" + s1);
                    System.out.println(getName() + ":" + s2);
                }
            }
        }.start();
        new Thread() { //Thread的匿名实现类
            @Override
            public void run() {
                synchronized (s2) {
                    s1.append("b");//持有同步锁 s2，等待s1被释放，造成死锁
                    System.out.println(getName() + ":" + s1);
                    System.out.println(getName() + ":" + s2);
                }
            }
        }.start();
    }
}

public class CommunicationTest {
    public static void main(String[] args) {
        CommunicationThread ct = new CommunicationThread();
        Thread t1 = new Thread(ct, "Thread-1");
        Thread t2 = new Thread(ct, "Thread-2");
        t1.start();
        t2.start();
    }
}
//这里使用实现Runnable接口的方式
class CommunicationThread implements Runnable {
    private int number = 0;
    public void run() {
        while (true) {
            synchronized (this) {
                notify(); //唤醒另一个线程，只有两个线程，也可以使用notifyAll
                if (number < 100) {
                    number++;
                    System.out.println(Thread.currentThread().getName() 
                                       + ":" + number);
                    try {
                        wait(); //当前线程进入阻塞状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else break;

            }
        }
    }
}