Java 多线程

拼搏现实的明天。 2021-09-18 14:30 266阅读 0赞

创建线程的三种方式  
第一种：通过继承Thread来创建线程，并重写 Thread 类中的 run 方法，通过调用 start 方法，但这种方式只允许单继承

@NoArgsConstructor
    @Setter
    class ThreadDemo extends Thread {
    
        private String threadName;
        
        // 重写线程父类 Thread 的 run 方法
        public void run() {
            for(int i = 0; i < 10000; i++){
                System.out.println("线程名字：" + threadName + " >>> " + i);
            }
        }
    
        // main 方法被程序主线程
        public static void main(String args[]) {
            ThreadDemo threadDemo1 = new ThreadDemo();
            threadDemo1.setThreadName("线程一");
            threadDemo1.start();
    
            ThreadDemo threadDemo2 = new ThreadDemo();
            threadDemo2.setThreadName("线程二");
            threadDemo2.start();
    		
    		// 下面是运行的是主线程，放在main方法最前面，最后面都是一样的
            for(int k = 0; k < 10000; k++){
                System.out.println("线程名字：" + Thread.currentThread().getName() + " >>> " + k);
            }
        }
    }

第二种：实现 Runable 接口，并实现 run 方法，实际开发中，选这种方式

@NoArgsConstructor
    @Setter
    class ThreadDemo implements Runnable {
        private String threadName;
    
        public void run() {
            for(int i = 0; i < 10000; i++){
                System.out.println("线程名字：" + Thread.currentThread().getName() + " >>> " + i);
            }
        }
    
        // main 方法被程序主线程
        public static void main(String args[]) {
            ThreadDemo threadDemo = new ThreadDemo();
            Thread thread1 = new Thread(threadDemo);
            thread1.setName("线程一");
            thread1.start();
    
            Thread thread2 = new Thread(threadDemo);
            thread2.setName("线程二");
            thread2.start();
    
            // 下面是运行的是主线程，放在main方法最前面，最后面都是一样的
            for(int k = 0; k < 10000; k++){
                System.out.println("线程名字：" + Thread.currentThread().getName() + " >>> " + k);
            }
        }
    }

第三种：使用匿名类

class ThreadDemo{
        // main 方法被程序主线程
        public static void main(String args[]) {
           new Thread(() -> {
               for(int k = 0; k < 10000; k++){
                   System.out.println("线程一：" + " >>> " + k);
               }
           }).start();
    
            new Thread(() -> {
                for(int k = 0; k < 10000; k++){
                    System.out.println("线程二：" + " >>> " + k);
                }
            }).start();
    
            // 下面是运行的是主线程，放在main方法最前面，最后面都是一样的
            for(int k = 0; k < 10000; k++){
                System.out.println("主线程：" + " >>> " + k);
            }
        }
    }

第四种：使用线程池

在这里插入代码片

二、线程的挂起和恢复  
**挂起：** 暂停这个线程的执行  
挂起线程的方式  
**被废弃的方法**

*  thread.suspend() 该方法不会释放线程所占用的资源。如果使用该方法将某个线程挂起，则可能会使其他等待资源的线程死锁
 *  thread.resume() 方法本身并无问题，但是不能独立于suspend()方法存在

**可以使用的方法**

*  wait() 暂停执行、放弃已经获得的锁、进入等待状态
 *  notify() 随机唤醒一个在等待锁的线程
 *  notifyAll() 唤醒所有在等待锁的线程，自行抢占cpu资源

**适合使用挂起线程的场景：**  
我等的船还不来(等待某些未就绪的资源)，我等的人还不明白。直到notify方法被调用

public class ProductTest {
    
        public static void main(String[] args) {
    
            Clerk clerk = new Clerk();
            Producter producter = new Producter(clerk);
            Consumer consumer = new Consumer(clerk);
            Thread thread1 = new Thread(producter);
            thread1.setName("生产者");
            Thread thread2 = new Thread(consumer);
            thread2.setName("消费者");
            thread1.start();
            thread2.start();
    
        }
    
        public static class Clerk {
            // 产品数量
            int productNums = 0;
    
            // 利用下城,增加产品数量,店员获取到的数量达到100个后，将不会继续增加。就等待消费者来取东西了
            public synchronized void addProduct() {
    
                if (productNums >= 100) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    productNums = productNums + 1;
                    System.out.println(Thread.currentThread().getName() + ":" + "添加了第" + productNums + "个产品");
                    notify();// 产品数量没到上线，通知其他线程来进行存或则取
                }
            }
    
            public synchronized void getProduct() {
                if (productNums <= 0) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + ":" + "买走了第" + productNums + "个产品");
                    productNums = productNums - 1;
                    notifyAll();// 产品数量没到下线，通知其他线程来进行存或则取
                }
            }
        }
    
        // 生产者要执行的线程
        public static class Producter implements Runnable {
    
            private Clerk clerk;
    
            public Producter(Clerk clerk) {
                this.clerk = clerk;
            }
    
            @Override
            public void run() {
                while (true) {
                    try {
                        // 不知道什么时候生产者回来添加产品,所以用一个随机时间来让进行线程随眠,来模仿生产者来访的不定时
                        Thread.sleep((int) (Math.random() * 10) * 100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    clerk.addProduct();
                }
            }
        }
    
        // 消费者需要执行的线程
        public static class Consumer implements Runnable {
    
            private Clerk clerk;
    
            public Consumer(Clerk clerk) {
                this.clerk = clerk;
            }
    
            @Override
            public void run() {
    
                while (true) {
                    try {
                        // 不知道什么时候消费者回来添加产品,所以用一个随机时间来让进行线程随眠,来模仿消费者来访的不定时
                        Thread.sleep((int) (Math.random() * 10) * 100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    clerk.getProduct();
                }
            }
        }
    }

中断方式：

public class Demo implements Runnable{
        private static volatile   boolean FLAG = true;
    
        @Override
        public void run() {
            while (FLAG) {
                System.out.println(Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new Demo());
            thread.start();
            Thread.sleep(1000L);
            FLAG = false;
        }
    }

或者如下：

public class Demo implements Runnable{
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName());
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
            Thread thread = new Thread(new Demo());
            thread.start();
            Thread.sleep(1000L);
            thread.interrupt();
        }
    }

07 线程的优先级  
线程的优先级告诉程序该线程的重要程度有多大。如果有大量线程都被堵塞，都在等候运行，程序会尽可能地先运行优先级的那个线程。 但是，这并不表示优先级较低的线程不会运行。若线程的优先级较低，只不过表示它被准许运行的机会小一些而已。

线程的优先级设置可以为1-10的任一数值，Thread类中定义了三个线程优先级，分别是：
    	MIN_PRIORITY（1）、NORM_PRIORITY（5）、MAX_PRIORITY（10），一般情况下推荐使用这几个常量，不要自行设置数值。
    
    	不同平台，对线程的优先级的支持不同。 	编程的时候，不要过度依赖线程优先级，如果你的程序运行是否正确取决于你设置的优先级是否按所设置的优先级运行，那这样的程序不正确
    
    	任务：
    		快速处理：设置高的优先级
    		慢慢处理：设置低的优先级
    
    
    
    
    08 守护线程
    	线程分类
    		用户线程、守护线程
    		守护线程：任何一个守护线程都是整个程序中所有用户线程的守护者，只要有活着的用户线程，守护线程就活着。当JVM实例中最后一个非守护线程结束时，也随JVM一起退出
    
    		守护线程的用处：jvm垃圾清理线程
    
    	建议： 尽量少使用守护线程，因其不可控
    		  不要在守护线程里去进行读写操作、执行计算逻辑