JavaSE多线程

Java多线程

实现多线程的几种方式

继承Thread类

• 自定义线程类继承Thread类
• 重写run()方法
• 创建线程对象，调用start()方法启动线程

public class MyThread entends Thread {
    @Override
    public void run() {
        // ...
    }
}

public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

实现Runnable接口

• 实现Runnable接口
• 实现run()方法
• 创建线程对象，调用start()方法

public class MyRunnable implements Runnable {
    @override
    public void run() {
        // ...
    }
}

public static main(String[] args) {
    MyRunnable mr = new MyRunnable();
    new Thread(mr).start();
}

实现Callable接口

• 实现Callable接口，需要返回值类型
• 重写call方法，需要抛出异常

ExecutorService ser = Executors.newFixedThreadPool(1);
Future<boolean> result = ser.submit(t1);
boolean r = result.get();
ser.shutdownNow();

Lambda表达式

new Thread(()->{
    // ...
}).start();

线程的状态：创建、就绪、阻塞、运行、死亡

stop：使用标志位

public class testStop implements Runnable {
    // 标志位
    private boolean flag = true;
    @Override
    public void run() {
        while(flag) {
            System.out.println("running ");
        }
    }
    // 提供标示
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        testStop ts = new testStop();
        new Thread(ts).start();
        // 主线程
        for(int i = 1; i <= 50; i++) {
            System.out.println("main " + i);
            // 主线程i=30, 停止运行ts
            if(i == 30) {
                ts.stop();
                System.out.println("stop!");
            }
        }
    }
}

sleep: 线程休眠, 线程阻塞的毫秒数

• 每个对象都有一个锁，sleep不会释放锁。

public class testSleep {
    // sleep 存在异常InterruptedException
    public static void countDown() throws InterruptedException {
        int n = 10;
        while(n > 0) {
            Thread.sleep(100);
            n--;
        }
    }
    public static void main(String[] args) {
        Date time = new Date(System.currentTimeMillis());
        try {
            System.out.println(new SimpleDateFormat("hh:mm:ss").format(System.currentTimeMillis()));
            countDown();
            time = new Date(System.currentTimeMillis());
            System.out.println(new SimpleDateFormat("hh:mm:ss").format(System.currentTimeMillis()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

yield: 线程礼让，当前正在执行的线程暂停，不阻塞，让CPU重新调度

public class testYield {
    public static void main(String[] args) {
        MyYield my = new MyYield();
        new Thread(my,"a").start();
        new Thread(my, "b").start();
    }
}

class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " at work");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + " out of work");
    }
}

Join: 线程合并，先执行此线程，其他线程阻塞

public class testJoin {
    public static void main(String[] args) throws InterruptedException {
        MyJoin mj = new MyJoin();
        Thread td = new Thread(mj);
        td.start();

        for(int i = 0; i < 10; i++) {
            System.out.println("main: " + i);
            if(i == 8) td.join();
        }
    }
}

class MyJoin implements Runnable {
    @Override
    public void run() {
        for(int i = 1; i <= 100; i++) {
            System.out.println("vip: " + i);
        }
    }
}

线程同步:

第一个线程访问，锁定同步监视器，执行其中的代码
第二个线程访问，发现同步监视器被锁定，无法访问
第一个线程访问完毕，解锁同步监视器
第二个线程访问，锁定访问

• synchronized：同步方法
• synchronize(Obj)：同步块

生产者/消费者模式

方式一：管程法

public class testPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(container).start();
    }

}

class Productor extends Thread {
    SynContainer container;
    public Productor(SynContainer container) {
        this.container = container;
    }
    public void run() {
        for(int i = 0; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i + "只鸡");
        }
    }
}

class Consumer extends Thread {
    SynContainer container;
    public Consumer(SynContainer container) {
        this.container = container;
    }
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("消费了-->" + container.pop().id + "只鸡");
        }
    }
}
class Chicken {
    int id;
    public Chicken(int id) {
        this.id = id;
    }
}

class SynContainer {
    Chicken[] chickens = new Chicken[10];
    int count = 0;
    public synchronized void push(Chicken chicken) {
        if (count == chickens.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        chickens[count] = chicken;
        count++;
        this.notifyAll();
    }
    public synchronized Chicken pop() {
        if(count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        count--;
        Chicken chicken =  chickens[count];
        return chicken;
    }
}

java中的notify和notifyAll区别

• 锁池：假设线程A已经拥有了某个对象的锁，而其他线程想要调用这个对象的synchronized方法，由于这些线程在进入对象的synchronized方法之前必须获得该对象的锁的拥有权，但该线程被线程A占用，因此，这些线程进入了该对象的锁池。

• 等待池：假设一个线程A调用某个对象的wait()方法，线程A会释放该对象的锁，进入到该对象的等待池

• 如果线程调用了该对象的wait()方法，线程便会处于该对象的等待池中，等待池中的线程不会竞争该对象的锁

• 当有线程调用对象的notifyAll()方法或者notify()方法，随机唤醒一个wait线程，被唤醒的线程会进入该对象的锁池中，锁池中的线程会竞争该对象锁。

• 优先级高的线程竞争到对象锁的概率大，若某个线程没有竞争到该对象锁，它会留在锁池中，唯有线程再次调用wait()方法，他才会重新回到等待池中。而竞争到对象锁的线程继续向下执行，直到执行完synchronized代码块，释放该对象的锁，锁池中的锁继续竞争。

方式二：信号灯法，标志位

public class testPC2 {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher((tv)).start();
    }
}

class Player extends Thread {
    Tv tv;
    public Player(Tv tv) {
        this.tv = tv;
    }
    public void run() {
        for (int i = 0; i < 20; i++) {
            if(i % 2 == 0) {
                this.tv.play("abc");
            } else {
                this.tv.play("def");
            }
        }
    }
}

class Watcher extends Thread {
    Tv tv;
    public Watcher(Tv tv) {
        this.tv = tv;
    }
    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

class Tv {
    String voice;
    // 标志位
    boolean flag = true;
    public synchronized void play(String voice) {
        if(!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了：" + voice);
        this.voice = voice;
        this.flag = !this.flag;
    }
    public synchronized void watch() {
        if(flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了：" + voice);
        this.notifyAll();
        this.flag = !this.flag;
    }
}

线程池

• 传入Runnable接口

public class testpool {
    public static void main(String[] args) {
        // 参数为线程池中线程个数
        ExecutorService ser = Executors.newFixedThreadPool(10);

        ser.execute(new MyThread());
        ser.execute(new MyThread());
        ser.execute(new MyThread());
        ser.execute(new MyThread());
        // 关闭
        ser.shutdown();
    }
}
class MyThread implements Runnable {
    @Override
    public void run() {
        for(int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}