多线程(Thread)

多线程(Thread)

1.认识线程

概念：

• 进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。每个进程至少有一个线程存在，即主线程。

2.用代码感受线程

public class ThreadDemo {
    /**
     * 内部实现静态线程类
     */
    private static class MyThread extends Thread{
        //1.重写run方法

        @Override
        public void run() {
            System.out.println("第一个线程代码感受!");
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

import java.util.Random;

public class ThreadDemo {
    /**
     * 内部实现静态线程类
     */
    private static class MyThread extends Thread{
        //1.重写run方法

        @Override
        public void run() {
            //System.out.println("第一个线程代码感受!");
            Random random = new Random();
            while (true) {
                // 打印线程名称
                System.out.println(Thread.currentThread().getName());
                try {
                    // 随机停止运行 0-9 秒
                    Thread.sleep(random.nextInt(10));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        MyThread t3 = new MyThread();
        t1.start();
        t2.start();
        t3.start();


        Random random = new Random();
        while (true){
            //currentThread()返回对当前正在执行的线程对象的引用
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(random.nextInt(10));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

结果：

3.创建一个新的执行线程有两种方法

• 创建一个新的执行线程有两种方法。 一个是将一个类声明为Thread的子类。 这个子类应该重写run类的方法Thread 。 然后可以分配并启动子类的实例。(就是上面的感受代码)。
• 另一种方法来创建一个线程是声明实现类Runnable接口。 那个类然后实现了run方法。 然后可以分配类的实例，在创建Thread时作为参数传递，并启动。(如下)。

start()导致此线程开始执行; Java虚拟机调用此线程的run方法。

public class ThreadDemo {
   
    private static class MyThread2 implements Runnable{
        @Override
        public void run() {
            System.out.println("继承Runable实现线程");
        }
    }

    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        new Thread(myThread2).start();
    }
}

4.多线程的优势-增加运行速度

• 接下来通过代码的运行来感受多线程是否增加了运行速度;
• 可以观察多线程在一些场合下是可以提高程序的整体运行效率的;

package 通过代码感受线程;

/**
 * 多线程的优势-增加运行速度
 */
public class ThreadDemo2 {
    private static final long count = 10_0000_0000;

    public static void main(String[] args) throws InterruptedException {
        //1.使用并发的方式，也就是多线程的方法
        concurrency();

        //2.使用串行的方式，也就是我们正常写代码的方式，对比多线程来说就是单线程，全部靠主线程来进行运算
        serial();
    }

    //多线程
    private static void concurrency() throws InterruptedException {
        long begin = System.currentTimeMillis();//开始运行时间
        //1.利用子线程计算a的值
        Thread thread = new Thread( new Runnable(){
            @Override
            public void run() {
                long a = 0;
                for (long i = 0;i < count;i++){
                    a++;
                }
            }
        });
        thread.start();
        //2.主线程计算b的值
        long b =0;
        for (long i = 0;i < count;i++){
            b++;
        }
        // 等待 thread 线程运行结束
        thread.join();

        long end = System.currentTimeMillis();//运行结束时间

        System.out.println("多线程时间是："+(end-begin));
    }

    //单线程
    private static void serial() {
        long begin = System.currentTimeMillis();//开始运行时间
        //1.将a和b的计算全部都放在主线程里面
        long a = 0;
        for (long i = 0;i < count;i++){
            a++;
        }

        long b = 0;
        for (long i = 0;i < count;i++){
            b++;
        }

        long end = System.currentTimeMillis();//运行结束时间

        System.out.println("单线程时间是："+(end-begin));
    }
}

结果：

5. Thread 类及常见方法

6.观察线程的所有状态

public class ThreadDemo {
    /**
     * 观察线程的所有状态，总共有6中状态
     * NEW ：新建
     * RUNNABLE ：就绪
     * BLOCKED ： 阻塞
     * WAITING：等待
     * TIMED_WAITING ：带时限的等待(超时等待)
     * TERMINATED ： 终止
     * @param args
     */
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()){
            System.out.println(state);
        }
    }
}

结果显示：

1.Java中线程的生命周期

7.多线程案列—单例模型(饿汉模式和懒汉模式)