启动一个线程

启动线程用start()方法。当用start()开始一个线程后，线程就进入就绪状态，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。当cpu分配给它时间时，才开始执行run()方法(如果有的话)。start()是方法,它调用run()方法.而run()方法是必须重写的. run()方法中包含的是线程的主体。

使用线程既可以继承Thread方法（extends）也可以实现Runnable接口（implements）

继承Thread线程类，重写run（）方法

public class MyThread extends Thread {
    private static int count = 0;
    private static boolean setStop = false;

    public MyThread(String name) {
        super(name);
    }

    public static void setStop(boolean setStop) {
        MyThread.setStop = false;
    }

    @Override
    public void run() {
        synchronized ("abc") {
            //对于静态方法，方法前有synchonized关键字，其实是把”类的对象“作为同步锁来使用，一个类，只有一个”当前类，类型的对象“
            //可以简单理解为：把当前类作为同步锁了
            for (int i = 0; i < 10; i++) {
                count++;
                System.out.println("当前线程开始执行，线程的ID为：" + Thread.currentThread().getId() +
                        "线程的名称：" + Thread.currentThread().getName() + "，当前count= " + count);

               /* try {//调用此方法，会休眠指定时间长度的时间，与此同时，当前线程不会交出同步锁的权限（其他线程无法进入）
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/

                try {
                    //调用此方法时，会无限制的等待下去，与此同时，当前线程会交出同步锁的权限，（其他线程得以进入同步块）
                    //此时线程处于一种“等待被唤醒”的状态，若有人通过同步锁唤醒当前线程（notify、notifyAll），它会继续执行
                    "abc".wait();//必须使用当前同步块后的锁对象，来进行线程通信（wait、notify、notifyAll）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (setStop == true){//退出线程
                    return;
                }
            }
        }
    }
}

调用线程

public class MianClass {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++){
            Thread thread = new MyThread("线程" + (i + 1));
            thread.start();
        }

        Scanner src = new Scanner(System.in);
        int a = 0;
        do {
            System.out.println("请输入一个整数：（正数代表执行一个线程，，0代表执行所有线程，但线程执行10个后会继续排队；负数代表退出循环体，不是退出线程）");
            a = src.nextInt();
            //唤醒线程同步块
            synchronized("abc"){
                if (a > 0){
                    "abc".notify();
                }else if (a == 0){
                    "abc".notifyAll();
                }
            }
        }while (a >= 0);

        MyThread.setStop(true);
        synchronized("abc"){//释放所有线程
            "abc".notifyAll();//
        }


    }
}