多线程基础知识（上）_音乐播放是单线程-优快云博客

public class Pre01 {
    public static void main(String[] args) throws InterruptedException {
        P p = new P();
        //启动线程
        p.start();
        for (int i = 0; i < 80; i++) {
            //线程休眠 一秒钟  此处会有异常需要我们处理
            Thread.sleep(1000);
            System.out.println("主线程"+i);
        }
        System.out.println("主线程继续执行");
    }
}
class P extends  Thread{
    @Override
    public void run() {
        for (int i = 0; i < 80; i++) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"线程被调用"+i);
    }
    }
}

执行结果如下（部分）

Thread-0线程被调用9
主线程9
Thread-0线程被调用10
主线程10
主线程11
Thread-0线程被调用11
Thread-0线程被调用12
主线程12
Thread-0线程被调用13

总结

1.可以清晰得出两个线程是同时交替执行的

2.为什么p不直接调用run方法而是调用start方法呢

请看源码 start源码在其中调用了start0方法

/* 1.start方法   
public synchronized void start() {
   start0();
}

start0方法中重写并调用了run方法

2.start0方法
//真正实现多线程的效果是start0() 而不是run
//start方法调用start0方法后 该线程并不一定会马上执行  只是将线程变成了可运行状态 具体什么时候 取决于cpu
 private native void start0();
@Override
public void run() {
    if (target != null) {
        target.run();
    }
}

如果你单纯调用run方法的话 相当于调用了一个普通方法 并不会创建线程这样会使得先执行run方法再去执行主线程 本质上还是一个线程

第二种方法：实现Runnable接口

第二种方法更好的满足适应了java单继承的特性因为java只能单继承如果利用了第一种方法那么就无法再继承其他的类了所以我们一般来说更为推荐第二种方法即通过实现接口来创建线程

public class Pre02 {
    public static void main(String[] args) throws InterruptedException{
        P1 p1 = new P1();
        //此处可以认为p1 转换成了Thread类 因为两者其实都实现了Runnable接口
        Thread thread = new Thread(p1);
        thread.start();
        for (int i = 0; i < 80; i++) {
            Thread.sleep(1000);
            System.out.println("主线程"+i);
        }
    }
}
class P1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 80; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }
            System.out.println("子线程"+i);
        }
    }
}

总结：

1.两个方法没有本质上的区别都实现了Runnable接口

2.关于P1那段描述可能不太准确具体的底层机制我也还不了解只是参考前面所学做出的推测

多线程售票问题

三个窗口共同卖一百张火车票运用多线程实现

public class Pre03 {
    public static void main(String[] args) {
        D d = new D();
        D d1 = new D();
        D d2 = new D();
        d.start();
        d1.start();
        d2.start();
    }
}
class D extends Thread{
  private static int nums = 100;
//一共一百张票
    @Override
    public void run() {
        while(nums>=0){
            System.out.println(Thread.currentThread().getName()+"线程(窗口)售出了一张还有"+nums--+"张");
        }
    }
}

最后可能会出现超发的结果这就牵扯到后面所说的锁的问题

线程终止

public class Thread05 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread = new Thread(t);
        thread.start();
        //主线程控制t1线程的终止 必须可以修改loop
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
            t.setLoop(false);
       
    }
}
class T implements Runnable{
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;
    @Override
    public void run() {
    while(loop){

        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("ok"+count);
        count++;
    }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }

    public int getCount() {
        return count;
    }
}

1.当线程完成任务后它会自动退出

2.还可以通过使用变量来控制run方法退出的方式停止线程即通知方式

只要在努力没有虚度时光就没有什么好焦虑的共勉！