java实现多线程

前言：线程到底单线程快，还是多线程快那，这个需要具体情况具体分析吧，如果一个服务器的cpu性能特别好，好几核，那么就可以开多线程来"串行"处理多个事情，如果一个服务器的cpu为单核，那么单线程肯定比多线程快，因为多线程还要受线程切换的影响，而且线程的生成和销毁都需时间，举个例子，就好比挖山，如果cpu性能好，那么一个进程就有100个工人,那就可以开两个线程从两头挖山，一头五十个人，如果cpu性能差，就一个工人，你还要开两个线程，一会让他从这头挖，一会让他从那头挖，他还要来回跑，反而浪费了时间
所以多线程的作用：
  a. 可以充分发挥cpu的性能，在多核处理器上，将要执行的任务分成多个可并行执行的线程，就可以提高执行效率(通俗解释，就是在大多的操作中，数据库访问、磁盘io等操作的速度比cpu执行代码的速度慢很多，如果是单线程，这些操作会阻塞程序的执行，导致cpu空转，而在多线程的情况下，你堵塞的情况下，我就用执行另一个线程去干别的事，所以多线程的精髓就是"等待即切换")
  b. 可以使程序多向运行，如果是单线程，那么你用电脑，就不能同时使用键盘和鼠标，总有一个不能用，而多线程，当你按下键盘的那一刻，这个线程就交出cpu然后堵塞，鼠标的线程有可能就在跑，或者其他线程在使用cpu在跑

1. java实现多线程有两种方法Thread和Runnable
2. Thread实现代码
   实现类Demo19Class代码：

// 多线程用法一

public class Demo19Class extends Thread {

    @Override
    public void run() {
        // 打印子线程的名字 1
        String stringName1 = getName();
        System.out.println(stringName1);

        // 打印子线程的名字 2
        String stringName2 = Thread.currentThread().getName();
        System.out.println(stringName2);

        // sleep 使子线程延迟1秒钟(单位：1000=1秒)
//        try {
//            Thread.sleep(1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }

        for (int i = 0; i < 1000; i++) {
            System.out.println("我就是继承了thread的子线程1-" + i);
        }

    }
}

实现类Demo21Class的代码：

// 多线程用法一

public class Demo21Class extends Thread {

    @Override
    public void run() {
        // 打印子线程的名字 1
        String stringName1 = getName();
        System.out.println(stringName1);

        // 打印子线程的名字 2
        String stringName2 = Thread.currentThread().getName();
        System.out.println(stringName2);

        for (int i = 0; i < 1000; i++) {

            System.out.println("我就是继承了thread的子线程2-" + i);
        }

    }
}

调用类Demo20Class代码：

// 开启多线程

public class Demo20Class {
    public static void main(String[] args) {
        // 打印主线程的名称
        String stringThreadName = Thread.currentThread().getName();
        System.out.println(stringThreadName);

        // 创建子线程对象1
        Demo19Class threadObj1 = new Demo19Class();

        // 给子进程重新起名字
        threadObj1.setName("子线程-1");

        // 使用start来开启子线程
        threadObj1.start();

        // 创建子线程对象2
        Demo21Class threadObj2 = new Demo21Class();

        // 给子进程重新起名字
        threadObj2.setName("子线程-2");

        // 使用start来开启子线程
        threadObj2.start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是main主线程" + i);
        }
    }
}

3. Runnable实现代码
   实现类Demo22Class的代码：

// 接口方式来实现多线程，好处就是解决了多继承的问题，这个类还可以继承别的接口类

public class Demo22Class implements Runnable{

    @Override
    public void run() {
        // 获取子线程名字
        System.out.println(Thread.currentThread().getName());

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是main主线程" + i);
        }
    }
}

调用类Demo23Class的代码：

// 调用多线程，实现和调用分为两个类，实现了解耦
// 接口多线程其实就是先创建实现类对象，然后放到Thread里面，然后执行start

public class Demo23Class {
    public static void main(String[] args) {
        // 打印主线程main名字
        System.out.println(Thread.currentThread().getName());

        // 先创建实现类对象
        Demo22Class realizeObj1 = new Demo22Class();

        // 然后将实现类对象放入Thread里面生成子线程对象
        Thread threadObj1 = new Thread(realizeObj1);

        // 给子进程重新命名
        threadObj1.setName("线程1");

        // 使用start启动子线程
        threadObj1.start();

        // 其实上面的几步可以写成一步
        // new Thread(new Demo22Class()).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("我是子线程" + i);
        }

    }

}