Java基础--多线程

举例：
System.out.println("1");
Thread thread = new Thread(new Runnable() {

    @Override
    public void run() {
       System.out.println("2");
   }
 });
thread.start(); //启动线程，等待JVM调度，不一定会立即执行。
System.out.println("3");
此时，异步，输出1， 3， 2

System.out.println("1");
Thread thread = new Thread(new Runnable() {

    @Override
    public void run() {
       System.out.println("2");
   }
 });
thread.run(); //不启动线程，立即执行。
System.out.println("3");
此时，同步，按顺序执行，输出1， 2， 3

【定义】
class MyThread extends Thread{
    @Override
    public void run() {
    }
}
【执行】
Thread myThread1 = new MyThread();
myThread1.start();

【举例】
class Demo extends Thread {

    @Override
    public void run() {
        System.out.println("1");
    }
}

public class Test {
    public static void main(String[] args) {
        Thread demo = new Demo();
        demo.start();
    }
}

【定义】
class MyRunnable implements Runnable{
    @Override
    public void run() {
    }
}
【执行】
Runnable myRunnable = new MyRunnable();
Thread myThread1 = new Thread(myRunnable);
myThread1.start();

【举例】
public class Test {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("1");
            }
        });
        thread.start();
    }
}

【定义】
class MyCallable implements Callable<Integer>{    
    @Override
    public Integer call() throws Exception {
        return null;
    }
}
【执行】
Callable<Integer> myCallable = new MyCallable();
FutureTask<Integer> ft = new FutureTask<Integer>(myCallable);
Thread myThread1 = new Thread(ft);
myThread1.start();

【举例】
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class Demo implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        Integer integer = 1;
        return integer;
    }

}

public class Test {
    public static void main(String[] args) {
        Callable<Integer> callable = new Demo();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            System.out.println(futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

若线程在阻塞状态（通过wait, join, sleep方法）时，调用了它的interrupt()方法，
那么它的“中断状态”会被清除并且会收到一个InterruptedException异常。
例如，线程通过wait()进入阻塞状态，此时通过interrupt()中断该线程；
调用interrupt()会立即将线程的中断标记设为“true”，但是由于线程处于阻塞状态，
所以该“中断标记”会立即被清除为“false”，
同时，会产生一个InterruptedException的异常。

【通用处理】
@Override
public void run() {
    try {
        /*
        isInterrupted()用于判断线程的中断标记是不是为true。
        当线程处于运行状态，并且我们需要终止它时；可以调用线程的interrupt()方法，
        使线程的中断标记为true，即isInterrupted()会返回true。
        此时，就会退出while循环。
        */
        // 1. isInterrupted()保证，只要中断标记为true就终止线程。
        while (!isInterrupted()) {
            // 执行任务...
        }
    } catch (InterruptedException ie) { 
        // 2. InterruptedException异常保证，当InterruptedException异常产生时，线程被终止。
    }
}

即
class Demo{
    Object obj = new Object();
    synchronized(obj){ //此时对obj对象有个同步锁。
    }
}

即
Demo demo = new Demo();
demo.show();//此时对Demo类的demo实例有个同步锁。

class Demo{
    public synchronized void show(){
    }
}

即
Demo.show();  //此时对Demo类有个同步锁，即对所有demo实例均有锁。
class Demo{
    public static synchronized void show(){
    }
}

【模拟生产者消费者问题：】
问题：
1、有一个果篮，生产者可以向果篮中放置苹果，消费者每次从果篮中拿一个苹果，并花一段时间吃苹果。
2、当果篮中苹果数为0时，消费者停止拿苹果，并通知生产者放入一定数量的苹果。
3、当果篮中苹果数大于0时，通知消费者拿苹果。
4、生产者每次通过控制台输入苹果数。

【果篮类，FruitBasket.java】
/**
 * 果篮类，用于存放苹果。
 *
 */
public class FruitBasket {
    private int appleNumber;// 果篮中苹果数

    /**
     * 构造方法，根据指定苹果数初始化果篮。
     * 
     * @param appleNumber
     *            苹果数
     */
    public FruitBasket(int appleNumber) {
        this.appleNumber = appleNumber;
    }

    /**
     * 同步方法，由于修饰的是非静态方法，所以锁对象为果篮类的实例。 获得果篮中的苹果数
     * 
     * @return 苹果数
     */
    public synchronized int getAppleNumber() {
        return appleNumber;
    }

    /**
     * 同步方法，由于修饰的是非静态方法，所以锁对象为果篮类的实例。 设置果篮中的苹果数
     * 
     * @param appleNumber
     *            苹果数
     */
    public synchronized void setAppleNumber(int appleNumber) {
        this.appleNumber = appleNumber;
    }

    /**
     * 同步方法，由于修饰的是非静态方法，所以锁对象为果篮类的实例。 消费者每次从果篮中拿一个苹果，果篮中苹果数每次减1。
     * 
     */
    public synchronized void decreaseNumber() {
        appleNumber--;
    }

    /**
     * 同步方法，由于修饰的是非静态方法，所以锁对象为果篮类的实例。生产者每次放置一定的苹果数，果篮中苹果数每次增加一定数量。
     * 
     * @param number
     *            苹果数
     */
    public synchronized void increaseNumber(int number) {
        appleNumber += number;
    }
}


【生产者类，Producer.java】
import java.util.Scanner;

/**
 * 生产者，生产苹果，并放置到果篮中。 通过控制台输入放置的苹果数。
 *
 */
public class Producer implements Runnable {

    private FruitBasket fruitBasket;// 定义一个果篮，用于存放苹果数
    private Scanner scanner;// 用于获取控制台输入的数据

    /**
     * 构造方法，用于初始化一个生产者。
     * 
     * @param fruitBasket
     *            果篮类
     * @param scanner
     *            输入类
     */
    public Producer(FruitBasket fruitBasket, Scanner scanner) {
        this.fruitBasket = fruitBasket;
        this.scanner = scanner;
    }

    /**
     * 重写run方法，用于实现生产者放苹果的逻辑。
     */
    @Override
    public void run() {
        while (true) {// 循环执行
            // 以果篮实例为同步锁，每次只允许一个生产者或者消费者线程进行操作。
            synchronized (fruitBasket) {
                System.out.println("n========================================================");
                System.out.println("当前果篮中苹果数为： " + fruitBasket.getAppleNumber());
                try {
                    System.out.println("生产者向果篮中放置苹果： ");
                    // 获取输入的苹果数
                    int number = Integer.parseInt(scanner.next());
                    // 向果篮中添加苹果
                    fruitBasket.increaseNumber(number);
                    System.out.println("放置苹果完成，当前果篮中苹果数为：  " + fruitBasket.getAppleNumber());

                    // 如果果篮中苹果数大于0，则通知消费者来拿苹果
                    if (fruitBasket.getAppleNumber() > 0) {
                        System.out.println("通知消费者来拿苹果。");
                        fruitBasket.notifyAll();// 通知所有的消费者
                        fruitBasket.wait();// 生产者等待
                    }
                } catch (NumberFormatException e) {
                    System.out.println("输入的数据格式错误，请重新输入。");
                } catch (InterruptedException e) {
                    System.out.println("系统异常");
                }
                System.out.println();
            }
        }
    }

}


【消费者类，Consumer.java】
/**
 * 消费者，每次从果篮中拿一个苹果。每拿一个苹果，需要吃一段时间。
 *
 */
public class Consumer implements Runnable {

    private FruitBasket fruitBasket;// 定义一个果篮，用于存放苹果数
    private long seconds;// 定义吃苹果时间
    private String name;// 消费者名

    /**
     * 根据果篮，休眠时间，名字来初始化一个消费者。
     * 
     * @param fruitBasket
     *            果篮
     * @param seconds
     *            吃苹果时间
     * @param name
     *            消费者名
     */
    public Consumer(FruitBasket fruitBasket, long seconds, String name) {
        this.fruitBasket = fruitBasket;
        this.seconds = seconds;
        this.name = name;
    }

    /**
     * 重写方法，用于实现消费者拿苹果的逻辑。
     */
    @Override
    public void run() {
        while (true) {// 循环执行
            // 以果篮实例为同步锁，每次只允许一个生产者或者消费者线程进行操作。
            synchronized (fruitBasket) {
                // 如果果篮中苹果数为0,
                if (fruitBasket.getAppleNumber() == 0) {
                    try {
                        // 通知生产者放置苹果。
                        fruitBasket.notifyAll();
                        fruitBasket.wait();// 消费者进行等待
                    } catch (InterruptedException e) {
                        System.out.println("系统错误");
                    }
                } else {// 如果果篮中苹果数大于0
                    System.out.println("n========================================================");
                    System.out.println("当前果篮中苹果数为：  " + fruitBasket.getAppleNumber());
                    System.out.println(name + " 开始拿苹果");
                    fruitBasket.decreaseNumber();// 果篮中苹果数减1
                    System.out.println(name + " 拿完苹果，当前果篮中苹果数为：  " + fruitBasket.getAppleNumber());
                    try {
                        System.out.println(name + " 开始吃苹果……");
                        long start = System.currentTimeMillis();
                        Thread.sleep(seconds * 1000);// 吃苹果的时间
                        long end = System.currentTimeMillis();
                        System.out.println(name + " 吃完苹果了：  " + (end - start));
                        fruitBasket.notifyAll();// 唤醒生产者和消费者
                        fruitBasket.wait();// 当前消费者等待
                    } catch (InterruptedException e) {
                        System.out.println("系统错误");
                    }
                }
                System.out.println();
            }
        }
    }

}


【测试类，ProducerAndConsumerDemo.java】
import java.util.Scanner;

/**
 * 测试功能。 使用3个线程表示消费者，1个线程表示生产者。 在果篮中没有苹果时，消费者停止拿苹果的操作，通知生产者放置苹果（通过控制台输入）。
 * 当果篮中有苹果时，通知消费者开始拿苹果，消费者每次拿完苹果后会花一定的时间吃苹果。
 *
 */
public class ProducerAndConsumerDemo {
    // 实例化一个果篮，用于存放苹果
    private static FruitBasket fruitBasket = new FruitBasket(0);
    // 实例化一个输入实例，用于获取控制台输入
    private static Scanner scanner = new Scanner(System.in);

    /**
     * 测试入口
     * 
     * @param args
     */
    public static void main(String[] args) {
        // 实例化一个生产者
        Thread producer = new Thread(new Producer(fruitBasket, scanner));
        producer.start();// 启动生产者

        // 实例化一个消费者A
        Thread consumerA = new Thread(new Consumer(fruitBasket, 3, "consumerA"));
        consumerA.start();// 启动消费者A

        // 实例化一个消费者B
        Thread consumerB = new Thread(new Consumer(fruitBasket, 2, "consumerB"));
        consumerB.start();// 启动消费者B

        // 实例化一个消费者C
        Thread consumerC = new Thread(new Consumer(fruitBasket, 4, "consumerC"));
        consumerC.start();// 启动消费者C
    }
}

【模拟电影院购票问题：】
import java.util.HashSet;
import java.util.Set;

/**
 * 电影院类
 */
class Cinema {

    private Set<Integer> seats;// 用于保存当前电影院还存在的位置
    private String cinemaName;// 用于保存电影院的名字

    /**
     * 构造方法，用于构造电影院
     * 
     * @param seats
     *            电影院当前还存在的位置
     * @param cinemaName
     *            电影院的名字
     */
    public Cinema(Set<Integer> seats, String cinemaName) {
        this.seats = seats;
        this.cinemaName = cinemaName;
    }

    /**
     * 获取电影院存在的座位位置
     * 
     * @return 电影院的座位位置
     */
    public Set<Integer> getSeats() {
        return seats;
    }

    /**
     * 设置电影院的座位位置
     * 
     * @param seats
     *            电影院的座位位置
     */
    public void setSeats(Set<Integer> seats) {
        this.seats = seats;
    }

    /**
     * 获取电影院的名字
     * 
     * @return 电影院的名字
     */
    public String getCinemaName() {
        return cinemaName;
    }

    /**
     * 设置电影院的名字
     * 
     * @param cinemaName
     *            电影院的名字
     */
    public void setCinemaName(String cinemaName) {
        this.cinemaName = cinemaName;
    }

    /**
     * 进行购票操作
     * 
     * @param buySeats
     *            需要购买的座位
     * @return true 表示购票成功 false 表示购票失败
     */
    public boolean buyTicket(Set<Integer> buySeats) {
        // 复制一份电影院座位表
        Set<Integer> copy = new HashSet<Integer>();
        copy.addAll(seats);

        // 减去被购买的座位
        copy.removeAll(buySeats);

        // 存在座位
        if (seats.size() - copy.size() == buySeats.size()) {
            seats.removeAll(buySeats);
            return true; // 成功购票
        }
        return false;// 不存在座位，购票失败
    }

    /**
     * 输出电影院剩余座位表
     */
    public void showTicket() {
        System.out.println("电影院当前剩余座位表如下：");
        for (Integer integer : seats) {
            System.out.print(integer + " ");
        }
        System.out.println();
        System.out.println();
    }
}

/**
 * 顾客类
 */
class Customer implements Runnable {

    private Set<Integer> buySeatSet; // 用于保存需要购买的座位
    private Cinema cinema;// 用于保存电影院

    /**
     * 构造方法，初始化顾客
     * 
     * @param buySeatSet
     *            购买的座位数
     * @param cinema
     *            电影院
     */
    public Customer(Set<Integer> buySeatSet, Cinema cinema) {
        this.buySeatSet = buySeatSet;
        this.cinema = cinema;
    }

    /**
     * 获取需要购买的座位
     * 
     * @return 需要购买的座位
     */
    public Set<Integer> getBuySeatSet() {
        return buySeatSet;
    }

    /**
     * 设置需要购买的座位
     * 
     * @param buySeatSet
     *            需要购买的座位
     */
    public void setBuySeatSet(Set<Integer> buySeatSet) {
        this.buySeatSet = buySeatSet;
    }

    /**
     * 获取电影院
     * 
     * @return 电影院
     */
    public Cinema getCinema() {
        return cinema;
    }

    /**
     * 设置电影院
     * 
     * @param cinema
     *            电影院
     */
    public void setCinema(Cinema cinema) {
        this.cinema = cinema;
    }

    @Override
    public void run() {
        synchronized (cinema) { // 对电影院加个锁，每次只允许一个顾客成功买票
            if (buySeatSet.size() > cinema.getSeats().size()) {
                System.out.println("电影院余票不足， 当前余票数为： " + cinema.getSeats().size());
            } else {
                if (cinema.buyTicket(buySeatSet)) {
                    System.out.println(Thread.currentThread().getName() + "购票成功！");
                } else {
                    System.out.println("当前位置不存在，" + Thread.currentThread().getName() + "购票失败！");
                }
            }
            cinema.showTicket();
        }
    }
}

/**
 * 测试类，用来模拟电影院购票操作
 */
public class TicketPurchaseDemo {

    public static void main(String[] args) {
        Set<Integer> seats = new HashSet<Integer>();
        for (int i = 1; i <= 10; i++) {
            seats.add(i);
        }
        Cinema cinema = new Cinema(seats, "Wanda");
        cinema.showTicket();

        Set<Integer> buySeats1 = new HashSet<Integer>();
        buySeats1.add(1);
        buySeats1.add(3);
        new Thread(new Customer(buySeats1, cinema), "孙悟空").start();

        Set<Integer> buySeats2 = new HashSet<Integer>();
        buySeats2.add(1);
        buySeats2.add(2);
        new Thread(new Customer(buySeats2, cinema), "猪八戒").start();

        Set<Integer> buySeats3 = new HashSet<Integer>();
        buySeats3.add(2);
        buySeats3.add(4);
        new Thread(new Customer(buySeats3, cinema), "唐三藏").start();
    }
}

【格式：】
    ()->{}。
若出现一个参数的情况，可以将()省略。
若出现一行代码的情况，可以将{}省略。
对于多个参数的情况，可以省略参数类型，但()不能省略。
若{}中只有一行代码，且为return语句，则可省略return。

【举例：】
interface Demo1 {
    void show();
}

interface Demo2 {
    int show(int a, int b);
}

public class LambdaDemo {
    public static void main(String[] args) {
        Demo1 demo1 = () -> {
            System.out.println("Demo1");
        };
        demo1.show();

        Demo1 demo12 = () -> System.out.println("Demo2");
        demo12.show();

        Demo2 demo3 = (int a, int b) -> {
            return a + b;
        };
        System.out.println(demo3.show(3, 4));

        Demo2 demo4 = (a, b) -> a + b;
        System.out.println(demo4.show(3, 4));
    }
}

public class ThreadLocalDemo {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
    private static ThreadLocal<Double> threadLocal2 = new InheritableThreadLocal<Double>();

    public static void main(String[] args) {
        /**
         * 测试ThreadLocal的get，set方法
         */
        // 设置main线程的名字为MainDemo
        Thread.currentThread().setName("MainDemo");
        // 参数为Integer型，所以初始值为null，所以输出MainDemo-->null
        System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        // 设置main线程保存的值为2
        threadLocal.set(2);
        // 设置值为2，所以输出MainDemo-->2
        System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());

        /**
         * 此行代码用于测试构造方法与run方法是由哪个线程调用
         */
        new Thread(new ThreadDemo(), "ThreadDemo").start();

        /**
         * 测试ThreadLocal，InheritableThreadLocal的区别
         */
        // 设置main线程保存的值为100
        threadLocal.set(100);
        // 设置值为100，所以输出MainDemo-->100
        System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        // 启动一个线程ThreadLocalDemo
        new Thread(() -> {
            // ThreadLocal会重新创造一个变量副本，所以输出ThreadLocalDemo-->null
            System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
            threadLocal.set(50);
            new Thread(() -> {
                // ThreadLocal会重新创造一个变量副本，所以输出ThreadLocalDemo1-->null
                System.out.println(Thread.currentThread().getName() + "-->" + threadLocal2.get());
            }, "ThreadLocalDemo1").start();
        }, "ThreadLocalDemo").start();

        // 设置main线程值为100.0
        threadLocal2.set(100.0);
        // 设置值为100.0，所以输出MainDemo-->100.0
        System.out.println(Thread.currentThread().getName() + "-->" + threadLocal2.get());
        // 启动一个线程InheritableThreadLocalDemo
        new Thread(() -> {
            // 其会拷贝上一个线程的值，上一个线程为main线程，所以输出为InheritableThreadLocalDemo-->100.0
            System.out.println(Thread.currentThread().getName() + "-->" + threadLocal2.get());
            threadLocal2.set(50.0);
            new Thread(() -> {
                // 其会拷贝上一个线程的值，上一个线程为InheritableThreadLocalDemo线程，所以输出为InheritableThreadLocalDemo-->50.0
                System.out.println(Thread.currentThread().getName() + "-->" + threadLocal2.get());
            }, "InheritableThreadLocalDemo1").start();
        }, "InheritableThreadLocalDemo").start();
    }

    public static class ThreadDemo implements Runnable {
        public ThreadDemo() {
            // 初始化时，由main线程调用，所以输出MainDemo-->2
            System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        }

        @Override
        public void run() {
            // 运行时，由当前线程调用，会重新创建一个变量副本，所以输出ThreadDemo-->null
            System.out.println(Thread.currentThread().getName() + "-->" + threadLocal.get());
        }
    }
}