Java多线程

线程的三种实现方式

  • 继承Thread类,重写run方法,调用start方法

    /*方法1:继承Thread类
    * 1、继承Thread类
    * 2、重写run方法
    * 3、创建线程实例
    * 4、调用start方法
    * */
    public class TestThread01 extends Thread{
        @Override
        public void run() {//重写run方法
            for (int i = 0; i < 20; i++) {
                System.out.println("正在执行子线程---"+i);
            }
        }
    
        public static void main(String[] args) {//main方法(主线程)
            TestThread01 thread01 = new TestThread01();//创建实例
            thread01.start();//调用start方法!不是run方法
            for (int i = 0; i < 1000; i++) {
                System.out.println("正在执行主线程========="+i);
            }
        }
    }
    
  • 实现Runnable接口

    /*方法2:实现Runnable接口
    * 1、实现Runnable接口
    * 2、重写run方法
    * 3、创建Runnable接口的实现对象
    * 4、使用Thread类调用start方法开启线程,(代理)
    * */
    public class TestThread2 implements Runnable{
        @Override
        public void run() {//重写run方法
            for (int i = 0; i < 20; i++) {
                System.out.println("正在执行子线程---"+i);
            }
        }
    
        public static void main(String[] args) {//main方法(主线程)
            //创建Runnable接口的实现对象
            TestThread2 thread2 = new TestThread2();
            //使用Thread开启线程,(构造器注入)
            new Thread(thread2).start();
            for (int i = 0; i < 1000; i++) {
                System.out.println("正在执行主线程========="+i);
            }
        }
    }
    
  • 实现Callable接口

并发问题

多个线程操作同一个对象时出现的问题

事例代码:

public class TestThread03 implements Runnable{
    private int tick = 10;
    @Override
    public void run() {
        while (true){
            if (tick<=0){
                break;
            }

            try {//模拟延时
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName()+"拿到了第"+tick+"票");
            tick--;
        }
    }

    public static void main(String[] args) {
        TestThread03 thread03 = new TestThread03();
        new Thread(thread03,"小明").start();
        new Thread(thread03,"小华").start();
        new Thread(thread03,"小红").start();
    }
}

执行结果

执行结果

线程使用

线程的生命周期

image-20200521130332101

线程方法

image-20200521130800602

线程停止

image-20200521131109400

public class ThreadStop implements Runnable{//设置标志位让线程停止

    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("线程正在执行。。。"+i++);
        }
    }

    public void stop(){//自定义停止
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadStop threadStop = new ThreadStop();
        new Thread(threadStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程"+i);
            if (i==900){
                threadStop.stop();
                System.out.println("线程已停止");
            }
        }
    }
}

线程休眠

==每个对象都有一把锁,sleep()方法不会释放锁==

线程礼让

Thread.yield() 可以暂停当前线程,礼让其他线程,但是不一定会礼让成功,主要还是看CPU调度

public class ThreadYield{

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

class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程正在运行···");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程已停止···");
    }
}

线程强制执行

可以在执行的线程队列中插入一个线程强制执行,其他线程被迫处于堵塞状态

public class ThreadJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程强制执行!"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ThreadJoin threadJoin = new ThreadJoin();
        Thread thread = new Thread(threadJoin);
        thread.start();

        for (int i = 0; i < 200; i++) {
            if (i==100){
                thread.join();
            }
            System.out.println("主线程在执行···"+i);
        }
    }
}

线程同步

synchronized(隐式)

image-20200524125219161


image-20200524125256816

lock锁(显式)

image-20200524124842343

image-20200524124746615

死锁

线程通信

典型例子:生产者消费者问题

image-20200524125624051

管程法

信号灯法

线程池

image-20200524132942709