目录

• 线程简介

• 线程实现(重点)

• 线程状态

• 线程同步(重点)

• 线程通信问题

线程实现:

方式一：继承Thread类

/**
 * TODO
 * @author 清莲孤舟
 * @CreateDate 2023/9/17/9:28
 * 创建线程的方式一:通过继承Thread类实现
 */
//继承Thread类
public class demo01 extends Thread {
//重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("副线程"+i);
        }
    }
//main主线程
    public static void main(String[] args) {
        demo01 demo01 = new demo01();
        //start方法启用线程
        demo01.start();
        //run()方法启用线程
        demo01.run();
        for (int i = 0; i < 20; i++) {
            System.out.println("主线程"+i);
        }
    }
}

　　我们先调用run方法运行(注意run()方法在主函数中的顺序):

副线程0    副线程1    副线程2    副线程3    副线程4    副线程5    副线程6    副线程7    副线程8    副线程9    
副线程10    副线程11    副线程12    副线程13    副线程14    副线程15    副线程16    副线程17    副线程18    副线程19

主线程0    主线程1    主线程2    主线程3    主线程4    主线程5    主线程6    主线程7    主线程8    主线程9    
主线程10    主线程11    主线程12    主线程13    主线程14    主线程15    主线程16    主线程17    主线程18    主线程19    

　　可以看出程序先运行完run线程再运行main主线程。符合程序按序执行的规制。同理如果将run()方法放在主函数的最后，那么先输出的将是"主线程"随后是"副线程"。

　　接下来我们调用start()方法:

主线程0    副线程0    主线程1    主线程2    主线程3    主线程4    副线程1    主线程5    主线程6    主线程7    副线程2    主线程8    主线程9    主线程10   主线程11   主线程12   副线程3    
主线程13   主线程14   主线程15   主线程16   主线程17   主线程18   主线程19   副线程4    副线程5    副线程6    副线程7    副线程8    副线程9    副线程10   副线程11   副线程12   副线程13   
副线程14   副线程15   副线程16   副线程17   副线程18   副线程19   

　　显而易见程序并不是按序执行的，而是交替并行的。这便是上节中介绍的并发，在一段时间内交替完成。

　　(PS：如果你在运行时发现输出结果并不是交替的，那么请将for循环次数增加，20次循环对于你的电脑来说太简单了)

方式二：实现Runnable接口（重点）

/**
 * TODO
 * @author Cooper
 * @CreateDate 2023/9/17/10:26
 * 创建线程方式二:实现Runnable接口
 */
public class demo02 implements Runnable{
//   同样的重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.print("副线程"+i+"\t");
        }
    }
    public static void main(String[] args) {
        demo02 demo02 = new demo02();
//        创建线程对象,通过线程对象开启线程
        Thread thread = new Thread(demo02);
        thread.start();
//      可以简写为该写法new Thread(demo02).start();
        for (int i = 0; i < 20; i++) {
            System.out.print("主线程"+i+"\t");
        }
    }
}

　　源码解析:

//Runnable源码 只有一个run()方法
public interface Runnable {
    public abstract void run();
}
//Thread方法 需要传入一个实现Runnable的对象
public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

　　运行结果:

主线程0    副线程0    主线程1    副线程1    主线程2    主线程3    主线程4    主线程5    副线程2    主线程6    
主线程7    主线程8    副线程3    主线程9    副线程4    主线程10    主线程11    主线程12    主线程13    主线程14    
主线程15    主线程16    主线程17    副线程5    主线程18    副线程6    副线程7    主线程19    副线程8    副线程9    
副线程10    副线程11    副线程12    副线程13    副线程14    副线程15    副线程16    副线程17    副线程18    副线程19    

线程并发案例：

　　这里使用狂神的案例:

/**
 * TODO
 *
 * @author Cooper
 * @CreateDate 2023/9/17/10:42
 */
public class demo03 implements Runnable{
    private int TicketNumber = 10;
    @Override
    public void run() {
        while (true){
            if(TicketNumber==0){
                break;
            }
            try {
                //线程暂停200ms
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //Thread.currentThread().getName()获取当前线程的名字
            System.out.println(Thread.currentThread().getName()+"===>拿到了第"+TicketNumber--+"票");
        }
    }
    public static void main(String[] args) {
        demo03 ticket = new demo03();
        new Thread(ticket,"小张").start();
        new Thread(ticket,"小李").start();
        new Thread(ticket,"小王").start();
    }
}

　　运行结果:

小李===>拿到了第8票
小张===>拿到了第10票
小王===>拿到了第9票
小王===>拿到了第6票
小李===>拿到了第7票
小张===>拿到了第7票
小李===>拿到了第3票
小王===>拿到了第4票
小张===>拿到了第5票
小李===>拿到了第2票
小王===>拿到了第2票
小张===>拿到了第2票
小张===>拿到了第1票
小王===>拿到了第1票
小李===>拿到了第1票

　　此时我们发现了一些问题--->同一张票被两个