java thread 怎么单线程 java单线程多线程

线程基本概念

单线程：同一个时刻，只允许执行一个线程

多线程：同一个时刻，可以执行多个线程，比如：一个qq进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

并发：同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单说，单核CPU实现的多任务就是并发

并行：同一个时刻，多个任务同时执行。多核CPU可以实现并行。

  线程基本使用

创建线程的两个方法：

（1）继承Thread类

（2）实现Runnable接口

案例1：继承Thread类

（1）编写程序，开启一个线程，该线程每隔1秒，在控制台输出“喵喵，我是小猫咪”

public class Thread01 {
    public static void main(String[] args) {
        //创建Cat对象，可以当作线程使用
        Cat cat = new Cat();
        cat.start();//启动线程
    }
}

class Cat extends Thread {

    public void run(){//重写run方法，写上自己的业务逻辑
        while (true) {
            //该线程每隔1秒。在控制台输出“喵喵，我是小猫咪”
            System.out.println("喵喵，我是小猫咪");
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

说明：

1.当一个类继承了Thread类，该类就可以当作线程使用

2.我们会重写run方法，写上自己的业务代码

3.run Thread类实现了Runnable接口的run方法

public void run(){
    if(target != null){
        target.run;
    }
}

（2）改进（1）：当输出8次“喵喵，我是小猫咪”，结束该线程

class Cat extends Thread {

    int times = 0;
    public void run(){//重写run方法，写上自己的业务逻辑
        while (true) {
            //该线程每隔1秒。在控制台输出“喵喵，我是小猫咪”
            System.out.println("喵喵，我是小猫咪" + (++times));
            //让该线程休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (times == 8){
                break;//当times到80，退出while，这时线程也就被退出。。
            }
        }
    }
}

（3）使用JConsole监控线程执行情况，并画出程序示意图

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当作线程使用
        Cat cat = new Cat();
        cat.start();//启动线程

        System.out.println("主线程继续执行" + Thread.currentThread().getName());//main
        for (int i = 0;i<10;i++) {
            System.out.println("主线程 i="+ i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}

说明：

1.当main线程启动一个子线程时，主线程不会阻塞，会继续执行

2.这时主线程和子线程交替执行

进程-->main线程-->子线程

??问题：为什么主函数中不直接使用cat.run();

当使用cat直接调用run方法时，并没有开启一个子线程，此时是 进程-->main线程  ，主线程执行完run方法后才能往后执行，会造成主线程的阻塞。真正实现多线程的效果是start0（），而不是run（）。

 案例2：实现Runnable接口

说明：

1.java是单继承的，在某些情况下一个类可能已经继承了某个父类，这是再用继承Thread类方法来创建线程显然是不可能的了。

2.java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。

请编写程序，该程序可以每隔1秒，在控制台输出“Hi”，当输出10次后，自动退出。请使用实现Runnable接口的方式实现。

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start  这里不能用start方法 Runnable接口里没有这个方法
        //创建一个Thread对象，把dog对象（实现Runnable）放入Theead
        Thread thread = new Thread(dog);
        //Runnable没有start方法开启线程，通过代理和动态绑定让tiger类开启线程执行run方法
        //Thread类里有一个构造器，这个构造器的参数是实现了Runnable接口的对象
        thread.start();
    }
}

class Dog implements Runnable {//通过实现Runnable接口，创建线程

    int count = 0;
    @Override
    public void run() {
        while(true) {
            System.out.println("小狗汪汪叫...hi" +(++count) + Thread.currentThread().getName());
            //休眠1秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10) {
                break;
            }
        }
    }
}

案例3：多线程执行

请编写一个程序，创建两个线程，一个线程每隔1秒输出“hello,world”，输出10次退出，一个线程每隔1秒输出“hi”，输出5次退出

public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();//启动第一个线程
        thread2.start();//启动第二个线程
    }
}

class T1 implements Runnable {

    int count = 0;
    @Override
    public void run() {
        //每隔1秒输出“hello,world”,输出10次
        while (true) {
            System.out.println("hello,world");
            count++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10)
                break;
        }
    }
}

class T2 implements Runnable {

    int count = 0;
    @Override
    public void run() {
        //每隔1秒输出“hi”,输出5次
        while (true) {
            System.out.println("hi ");
            count++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5)
                break;
        }
    }
}

继承Thread和实现Runnable的区别

1.从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本
质上没有区别，从idk帮助文档我们可以看到Thread类本身就实现了 Runnable接口
2.实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

建议使用Runnable

案例【售票系统】

编程模拟三个售票窗口售票100张，分别使用继承Thread和实现Runnable接口方式，并分析有什么问题

public class SellTicket {
    public static void main(String[] args) {

        //测试
//        SellTicket01 sellTicket01 = new SellTicket01();
//        SellTicket01 sellTicket02 = new SellTicket01();
//        SellTicket01 sellTicket03 = new SellTicket01();
//
//        sellTicket01.start();//启动售票线程
//        sellTicket02.start();//启动售票线程
//        sellTicket03.start();//启动售票线程

        System.out.println("===使用实现接口方式售票===");
        SellTicket02 sellTicket02 = new SellTicket02();
        new Thread(sellTicket02).start();//第一个线程
        new Thread(sellTicket02).start();//第二个线程
        new Thread(sellTicket02).start();//第三个线程
    }
}

//使用Thread
class SellTicket01 extends Thread {

    private  static int ticketNum = 100;//让多个线程共享ticketNum

    @Override
    public void run() {
        while(true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒,模拟卖票
            try {
                Thread.sleep(50);
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
                    +" 剩余票数："+(--ticketNum));
        }
    }
}

//实现Runnable接口方式
class SellTicket02 implements Runnable {

    private int ticketNum = 100;//让多个线程共享ticketNum

    @Override
    public void run() {
        while(true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }

            //休眠50毫秒,模拟卖票
            try {
                Thread.sleep(50);
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println("窗口 "+Thread.currentThread().getName()+" 售出一张票"
                    +" 剩余票数："+(--ticketNum));
        }
    }
}

运行结果：

说明：这种情况下因为休眠的原因会造成超卖的现象