Java-Thread 线程、进程、线程和进程的区别、线程执行方式、线程的生命周期、线程休眠、线程池

Thread是线程类

进程里面有线程 线程里面没有进程

currentThread方法用于获取当前正在运行的线程

getName方法用于获取线程名称

main方法运行在线程当中

    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()); //main
    }

线程的使用

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName()); //main
        //创建线程
//        Thread t = new Thread();
        MyThread t = new MyThread();
        t.start();
    }
}
//声明自定义线程类
class MyThread extends Thread {
    public void run() {
        System.out.println("MyThread: " + Thread.currentThread().getName()); //Thread-0

    }
}

线程的生命周期

                

线程执行方式

串行执行：多个线程连成串，然后按照顺序执行

并发执行：多个线程是独立的，谁抢到了CPU执行权，谁就能执行

虚拟机默认是并发执行 如果需要串行执行则需要Thread.join的方法

public class ThreadTest {
    public static void main(String[] args) throws Throwable {
        System.out.println(Thread.currentThread().getName()); //main
        //创建线程
//        Thread t = new Thread();
        MyThread1 t1 = new MyThread1();
        MyThread2 t2 = new MyThread2();
//        main
//        MyThread2: Thread-0
//        MyThread1: Thread-1
        t1.start();
        t2.start();
        //连接成串 串行
//        main
//        MyThread1: Thread-0
//        MyThread2: Thread-1
        t1.join();
        t2.join();
        System.out.println("main方法执行完毕");
    }
}
//声明自定义线程类
class MyThread1 extends Thread {
    public void run() {
        System.out.println("MyThread1: " + Thread.currentThread().getName()); //Thread-0

    }
}
class MyThread2 extends Thread {
    public void run() {
        System.out.println("MyThread2: " + Thread.currentThread().getName()); //Thread-0

    }
}

线程休眠

    public static void main(String[] args) throws Exception {
        while (true) {
            Thread.sleep(1000);
            System.out.println("main线程执行完毕");
        }
    }

自定义线程

1.继承线程类；

2.重写run方法；

public class ThreadRun {
    public static void main(String[] args) throws Exception {
        MyThread3 t3 = new MyThread3();
        MyThread4 t4 = new MyThread4();
        t3.start();
//        t3.join(); //串行
        t4.start();

        Thread t5 = new Thread(() -> {
            System.out.println("t5线程执行");
        });
        t5.start();
        Thread t6 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("t6线程执行");
            }
        });
        t6.start();
        System.out.println("main线程执行完毕");
    }
}
class MyThread3 extends Thread {
    @Override
    public void run() {
        System.out.println("t3线程执行");
    }
}
class MyThread4 extends Thread {
    @Override
    public void run() {
        System.out.println("t4线程执行");
    }
}

线程池

定义：所谓的线程池，就是线程对象的容器

可以根据需求，在启动时，创建一个或者多个线程对象

Java有四种常见的线程池 

1.创建固定数量的线程对象  ExecutorService是线程服务对象

ExecutorService executorService = Executors.newFixedThreadPool(3);

    ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
//                    pool-1-thread-3
//                    pool-1-thread-2
//                    pool-1-thread-1
//                    pool-1-thread-2
//                    pool-1-thread-3
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }

2.根据需求动态创建线程 根据任务使用的情况创建使用线程 会重复使用线程 

 ExecutorService executorService2 = Executors.newFixedThreadPool(3);

    ExecutorService executorService2 = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            executorService1.submit(new Runnable() {
                @Override
                public void run() {
//                    pool-2-thread-1
//                    pool-2-thread-5
//                    pool-2-thread-3
//                    pool-2-thread-2
//                    pool-2-thread-4
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }

3.单一线程

ExecutorService executorService3 = Executors.newSingleThreadExecutor();

        ExecutorService executorService3 = Executors.newSingleThreadExecutor();
        
        for (int i = 0; i < 5; i++) {
            executorService2.submit(new Runnable() {
                @Override
                public void run() {
//                    pool-2-thread-1
//                    pool-2-thread-1
//                    pool-2-thread-1
//                    pool-2-thread-1
//                    pool-2-thread-1
                    System.out.println(Thread.currentThread().getName());
                }
            });
        }
    }

4.定时调度线程

ExecutorService executorService4 = Executors.newScheduledThreadPool(3);

线程和进程的区别

1. 进程是程序的一次执行过程，它有自己的内存空间、资源和标识符。而线程是进程中的一个执行单元，线程与进程共享相同的内存和资源，但每个线程有自己的程序计数器、堆栈和局部变量。

2. 进程之间是独立的，互相不能干扰；而同一进程内的线程能共享数据和内存，互相之间可以通信。

3. 进程具有较高的稳定性和安全性，它们之间互相独立，一个进程的崩溃不会影响其他进程。线程则较为脆弱，因为它们共享相同的内存和资源，一个线程的崩溃可能会导致整个进程崩溃。

4. 进程的切换开销比较大，需要保存和恢复资源和状态信息；而线程的切换开销较小，因为它们共享资源和内存，只需要保存和恢复部分状态信息即可。

总的来说，线程和进程都有自己的优势和劣势，需要根据实际情况选择合适的方式进行开发和部署。