线程的三种实现方式

继承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();
    }
}

执行结果：

线程使用

线程的生命周期

线程方法

线程停止

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);
        }
    }
}