[Java] 线程操作

线程生命周期

• 创建：new一个Thread类的对象
• 就绪：调用start()方法，等待CPU调度
• 运行：系统为线程分配硬件资源后，线程按照核心业务的功能执行，但不是一直执行，需进行资源抢占，运行一段时间后一个线程就会让出当前的资源，然后重新等待调度
• 堵塞：当某一个线程对象让出了当前的资源，该线程对象进入阻塞状态（未完成代码暂不执行），除了系统的自动控制外，也可利用Thread类中的线程控制方法进行阻塞操作
• 终止：当线程方法全部执行完毕后，该线程将释放掉全部资源，并结束调用

线程命名

• Thread(Runnable target, String name)：实例化线程对象，接收Runnable接口子类对象，同时设置线程名称
• setName(String name)：设置线程名称
• getName(String name)：取得线程名称
• cuurentThread()：取得当前线程对象的方法
• 默认情况下返回的线程名为“Thread-xxx”，对象自动编号
• 调用run()的两种方式
  • Thread线程对象接收Runnable子类对象实例，通过start()调用
  • Runnable子类对象实例调用
• 每个JVM运行就是进程，每个JVM进程都至少启动两个线程
  • main：程序的主要执行，以及启动子线程（Thread创建）
  • gc：垃圾回收
• 写代码时，可将所有耗时操作利用子线程的形式进行定义，主线程完成主要功能操作，如子线程的创建、控制等

class MyThread implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

public class TestDemo {
    public static void main(String[] args) throws Exception{
        MyThread mt = new MyThread();
        new Thread(mt,"自己的线程").start();
        mt.run();
    }
}

 

线程休眠

• sleep()
• java.lang.InterruptException：休眠时间不到，非正常结束时抛出
• 进入到run()的线程的个数可能非常多，但是所有线程一旦遇到休眠后将按照各自的时间进行休眠处理，由于线程执行速度非常块，所以从整个的执行上来讲，好像是若干个线程一起休眠，一起唤醒
• 重写run()时定义每个线程的操作，main()中创建若干个线程同时执行run()，加了sleep就是run()中的每步操作执行完都停顿一下

 

线程中断

• 一个线程无法自己进行中断，必须由其他线程帮助完成中断
• interrupt()：线程中断
• isInterrupted()：判断线程的中断状态
• 线程中断一旦产生，一定会产生一个与之匹配的InterruptedException

public class Sleep_Demo {
    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(()->{
            try {
                System.out.println("["+Thread.currentThread().getName()+"]准备进入休眠状态，预计时间10秒...");
                Thread.sleep(10000);
                System.out.println("["+Thread.currentThread().getName()+"]休眠状态正常结束...");
            } catch (InterruptedException e) {
                System.out.println("["+Thread.currentThread().getName()+"]休眠产生异常，无法正常完成休眠...");
            }
        },"休眠线程");
        thread.start();
        System.out.println("[中断状态]" + thread.isInterrupted());
        Thread.sleep(2000);
        thread.interrupt();
    }
}

线程强制执行

• 正常情况下，线程间平等抢占资源
• 若某个线程非常重要，则需要强制性霸占资源，优先处理
• join()：持续执行直到线程结束

public class Sleep_Demo {
    public static void main(String[] args) throws Exception{
        Thread mainThread = Thread.currentThread();
        Thread joinThread = new Thread(()->{
            for(int x = 0 ; x < 1000 ; x ++ ){
                try {
                Thread.sleep(1000);
                if(x >= 10) {
                    mainThread.join(); // 子线程交出全部资源给主线程
                }
                System.out.println("["+Thread.currentThread().getName()+"]子线程执行，x = " + x);
            }catch(InterruptedException e) {
                e.printStackTrace();
                }
            }
        },"工作线程");
        joinThread.start(); // 启动子线程
        for(int x = 0 ; x < 1000 ; x ++ ) {
            Thread.sleep(1000);
            System.out.println("[" + Thread.currentThread().getName() + "]线程执行，x = " + x);
        }
    }
}

线程礼让

• 运行时线程轮流进行CPU资源抢占，当一个线程抢占了资源后，可通过礼让的形式让出资源
• public static void yield()：把到手的资源让给其他线程
• 实际开发中，由于会有若干个不同线程，需要为每一个线程设置一些名称标记表示其重要性（CEO、员工等）

public class Sleep_Demo {
    public static void main(String[] args) throws Exception{
        Thread mainThread = Thread.currentThread();
        Thread joinThread = new Thread(()->{
            for(int x = 0 ; x < 1000 ; x ++ ){
                try {
                    if(x % 2 == 0) {
                        Thread.yield();
                        System.out.println("[YIELD]线程礼让执行");
                    }
                    Thread.sleep(1000);
                    System.out.println("["+Thread.currentThread().getName()+"]子线程执行，x = " + x);
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"工作线程");
        joinThread.start(); // 启动子线程
        for(int x = 0 ; x < 1000 ; x ++ ) {
            Thread.sleep(1000);
            System.out.println("[" + Thread.currentThread().getName() + "]线程执行，x = " + x);
        }
    }
}

线程优先级

• 线程优先级越高，越有可能先执行
• 优先级常量
  • MAX_PRIORITY：最高优先级，数值10
  • NORM_PRIORITY：中等优先级，数值5
  • MIN_PRIORITY：最低优先级，数值1
• setPriority()：获取线程优先级
• getPriority()：修改线程优先级
• 主方法及子线程默认线程优先级为均为5
• 可在线程执行前修改优先级
• 线程的等待与唤醒

public class Sleep_Demo {
    public static void main(String[] args) throws Exception{
        // 定义线程数组
        Thread threads [] = new Thread[3];
        for(int x = 0 ; x < threads.length ; x ++ ) {
            threads[x] = new Thread(()->{
                while(true) {
                    try {
                    Thread.sleep(1000);
                    System.out.println("["+Thread.currentThread().getName()+"]线程执行，线程优先级"+Thread.currentThread().getPriority());
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
        }
        // 设置线程优先级
        threads[0].setPriority(Thread.MIN_PRIORITY);
        threads[2].setPriority(Thread.MIN_PRIORITY);
        threads[1].setPriority(Thread.MAX_PRIORITY);
        // 启动线程
        for(int x = 0 ; x < threads.length; x ++) {
            threads[x].start();
        }
    }
}

同步与死锁

• 多线程目的：提升程序在单位时间内的处理性能
• 可能产生的问题：一个人盖房子/多个人盖房子
  • 同步问题
    • 问题原因：由于休眠的出现，导致了票数修改的操作延迟，其余的线程也可以通过票数判断，当休眠结束后，所有的线程都执行票数减少操作，导致数据的修改错误
    • 类比：关起门上厕所，所有操作在门里完成，不受别人打扰
    • 锁处理机制：在Java里通过同步代码块、同步方法实现
    • 同步代码块：sychronized(锁定对象) 代码块，其中的操作在一个时间段内只能有一个线程执行，其他线程等此线程执行完后才可继续执行
    • 同步方法：public sychronized 返回值 方法名称(){代码}
    • 优点：保证程序的正确处理（线程安全性）
    • 缺点：异步执行的速度远高于同步执行，同步代码会导致性能下降（例：银行取钱）
  • 死锁问题
    • 产生：同步后线程之间相互等待，A要等B释放资源后才可执行，在这之前A进入到阻塞状态
    • 死锁：两个线程彼此等待对方先完成，造成了程序的停止状态
    • 死锁可能随机出现，开发时不易排查，可使用工具观察
• 多线程开发的两个模型
  • 共同参与：考虑同步、死锁问题
  • 生产者-消费者：

未加锁的程序：

public class Synchronize_Demo {
    public static int ticket = 5;
    public static void main(String[] args) throws Exception {
        Runnable body = () -> {
            while(true) {
                if(ticket > 0) {
                    try {
                    Thread.sleep(1000);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("["+Thread.currentThread().getName()+"]售票，当前剩余票数："+ (--ticket));
                }else {
                    break;
                }
            }
        };
        for(int x = 0 ; x <5 ; x ++) {
            new Thread(body,"票贩子-" + x).start();
        }
    }
}

加锁的程序（同步代码块）：

public class Synchronize_Demo {
    public static int ticket = 5;
    public static void main(String[] args) throws Exception {
        Synchronize_Demo SynDemo = new Synchronize_Demo();
        Runnable body = () -> {
            while(true) {
                synchronized(SynDemo) {
                    if(ticket > 0) {
                        try {
                        Thread.sleep(1000);
                        }catch(InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("["+Thread.currentThread().getName()+"]售票，当前剩余票数："+ (--ticket));
                    }else {
                        break;
                    }
                }
            }
        };
        for(int x = 0 ; x <5 ; x ++) {
            new Thread(body,"票贩子-" + x).start();
        }
    }
}

 或（同步方法）：

public class Synchronize_Demo {
    public static int ticket = 5;
    public static void main(String[] args) throws Exception {
        Synchronize_Demo SynDemo = new Synchronize_Demo();
        Runnable body = () -> {
            while(sale()) {}
        };
        for(int x = 0 ; x <5 ; x ++) {
            new Thread(body,"票贩子-" + x).start();
        }
    }
    
    public static synchronized boolean sale() {
        if(ticket > 0) {
            try {
                Thread.sleep(1000);
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("["+Thread.currentThread().getName()+"]售票，当前剩余票数："+ (--ticket));
            return true;
        }else {
            return false;
        }
    }
}

死锁：

class Book{}
class Paint{}

public class DeadLock_Demo {
    public static void main(String[] args) throws Exception{
        Book book = new Book();
        Paint paint = new Paint();
        Thread threadA = new Thread(()->{
            synchronized(book) {
                System.out.println("A对B说：你给我你的画，我再借你我的书");
                try {
                    Thread.sleep(1000);
                    
                    synchronized(paint) {
                        Thread.sleep(1000);
                        System.out.println("A得到了B的画");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread threadB = new Thread(()->{
            synchronized(paint) {
                System.out.println("B对A说：你借我你的书，我再给你我的画");
                try {
                    Thread.sleep(1000);
                    synchronized(book) {
                        Thread.sleep(1000);
                        System.out.println("B得到了A的书");
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }); 
        threadA.start();
        threadB.start();
    }
}

  

 

生产者与消费者

• 协同处理
  • 生产需要很多供需，如果有一道工序没有完成，则消费者无法取走商品
  • 生产者生产力很强，而消费者消费能力弱，则当某个商品已经生产完但未取走时，生产者应等待消费者取走后再进行后续的生产
  • 如果消费者能力很强，且发现没有新的商品可取走，则消费者需等待有新的产品生产出后再取走
  • 生产者和消费者是两个独立的线程
  • 线程的同步、等待、唤醒机制，在synchronized方法中使用，但容易导致死锁，实际开发多使用JUC编程
    • wait()：等待
    • notify()：唤醒
  • 实际应用：消息组件
  • 程序1问题
    • 生产者没有完成信息生产时消费者就已经获取数据了
    • 若消费者的性能高于生产者，则会出现信息重复消费的问题
    • 若生产者的性能高于消费者，则会出现信息重复生产的问题
  • 程序2问题
    • 仅解决了多线程并行修改数据的问题，但没有实现多线程间彼此协作的沟通

程序1

class Message{
    private String title;
    private String content;
    
    public void setTitle(String title) {
        this.title = title;
    }
    
    public void setContent(String content) {
        this.content = content;
    }
    
    public String getTitle() {
        return title;
    }
    
    public String getContent() {
        return content;
    }
}

class ProducerThread implements Runnable{
    private Message message;
    public ProducerThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 50 ; x ++ ) {
            try {
            if(x % 2 == 0) {
                this.message.setTitle("李兴华");
                Thread.sleep(1000);
                this.message.setContent("老师");
            }else {
                this.message.setTitle("沐言");
                Thread.sleep(1000);
                this.message.setContent("www.yootk.com");
                }
            }catch(Exception e) {}
        }
    }
}

class ConsumerThread implements Runnable{
    private Message message;
    public ConsumerThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 50 ; x ++ ) {
            System.out.println("[消费者]title="+this.message.getTitle()+", content = " + this.message.getContent());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

程序2（解决同步问题）

class Message{
    private String title;
    private String content;
    public synchronized void set(String title, String content) {
        this.title = title;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content;
    }
    public synchronized String get() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "title = " + this.title + ", content = " + this.content;
    }
}

class ProducerThread implements Runnable{
    private Message message;
    public ProducerThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 50 ; x ++ ) {
            if(x % 2 == 0) {
                this.message.set("李兴华","老师");
            }else {
                this.message.set("沐言","www.yootk.com");
            }
        }
    }
}

class ConsumerThread implements Runnable{
    private Message message;
    public ConsumerThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 50 ; x ++ ) {
            System.out.println("[消费者]"+this.message.get());
        }
    }
}

public class PC_Demo {
    public static void main(String[] args) throws Exception{
        Message message = new Message();
        new Thread(new ProducerThread(message)).start();
        new Thread(new ConsumerThread(message)).start();
    }
}

程序3（解决线程重复操作问题）

class Message{
    private String title;
    private String content;
    private boolean flag = true;
    // flag = true：可以生产，但无法进行消费
    // flag = false：可以消费，但无法进行生产
    public synchronized void set(String title, String content) {
        if(this.flag == false) {
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.title = title;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.content = content;
        this.flag = false;
        super.notify();
    }
    public synchronized String get() {
        if(this.flag == true) {
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.flag = true;
        super.notify();
        return "title = " + this.title + ", content = " + this.content;
    }
}

class ProducerThread implements Runnable{
    private Message message;
    public ProducerThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 50 ; x ++ ) {
            if(x % 2 == 0) {
                this.message.set("李兴华","老师");
            }else {
                this.message.set("沐言","www.yootk.com");
            }
        }
    }
}

class ConsumerThread implements Runnable{
    private Message message;
    public ConsumerThread(Message message) {
        this.message = message;
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 50 ; x ++ ) {
            System.out.println("[消费者]"+this.message.get());
        }
    }
}

public class PC_Demo {
    public static void main(String[] args) throws Exception{
        Message message = new Message();
        new Thread(new ProducerThread(message)).start();
        new Thread(new ConsumerThread(message)).start();
    }
}

 

  

停止线程

class Thread_Stop implements Runnable{
    private boolean flag = false; //停止标志
    @Override
    public void run() {
        for(int x = 0 ; x < 1000; x++) {
            if(this.flag) {
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("[Message信息输出——" + x + "]沐言科技：www.yootk.com");
        }
    }
    public void stop() {
        this.flag = true;
    }
}

public class Daemon_Thread_Demo {
    public static void main(String[] args) throws Exception{
        Thread_Stop message = new Thread_Stop();
        new Thread(message).start();
        Thread.sleep(500);
        message.stop();
    }
}

守护线程

• 守护线程工作在后台，用于监控服务器的状态

class Daemon_Thread implements Runnable{
    public Daemon_Thread() {
        Thread daemonThread = new Thread(()->{
            for(int x = 0 ; x < Integer.MAX_VALUE ; x++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("[守护线程]编程训练营");
            }
        });
        daemonThread.setDaemon(true); //设置为守护线程
        daemonThread.start(); //守护线程启动
    }
    @Override
    public void run() {
        for(int x = 0 ; x < 10; x++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("[Message信息输出——" + x + "]沐言科技：www.yootk.com");
        }
    }
}

public class Daemon_Thread_Demo {
    public static void main(String[] args) throws Exception{
        Daemon_Thread message = new Daemon_Thread(); //实例化
        new Thread(message).start(); //启动线程
    }
}

volatile关键字

• 多线程开发的本质在于多个线程彼此协作，更好地发挥硬件性能，在单位时间内执行更多的任务
• volatile定义的属性不具有同步操作的特点
• 传统程序变量的操作：
  • 如果进行变量的修改，一定要通过主内存将某个变量的内容拷贝到线程的内存中，此时为一个变量副本
  • 随后在线程内存里针对于变量的副本数据进行处理操作（赋值、修改等）
  • 当所有线程内存中的变量修改完成后则需与主内存中的变量内容进行同步处理
  • 线程内存和主内存间的变量就会有同步延迟
• volatile关键字的作用：不再进行副本的定义，直接操作主内存中的变量。避免了各种变量的拷贝及同步带来的延迟损耗（存在同步问题），可直接更快地访问主内存变量（直接进行主内存变量操作，可减少延迟，看起来好像是“同步”了）
• 使用volatile定义的变量可直接进行底层内存变量操作，使数据的同步更加高效