Java粗浅认识-并发编程（一）-线程简介

最新推荐文章于 2024-06-26 09:45:00 发布

zoQ

最新推荐文章于 2024-06-26 09:45:00 发布

阅读量195

点赞数 1

分类专栏： java 并发编程线程 Java粗浅认识文章标签： Java 并发编程线程

本文链接：https://blog.csdn.net/bpz31456/article/details/85161956

版权

java 同时被 3 个专栏收录

18 篇文章 0 订阅

订阅专栏

Java粗浅认识

16 篇文章 0 订阅

订阅专栏

并发编程

5 篇文章 0 订阅

订阅专栏

线程简介

进程，操作系统中分配资源的基本单元，线程，操作系统中运行的基本单元，在一个进程中可以包含一个或多个线程，进程间通信，资源共享效率低，在同一个进程中，所有线程共享资源。

线程在使用时，也存在各种问题，线程安全性，线程活跃性，线程性能

线程安全性

在多线程环境中，能够正确地处理多个线程之间的共享变量，使程序功能正确完成，这里的正确完成，就是每个线程得到预期值。

示例代码中，thread1和thread2共享资源ArrayList，而ArrayList本身并不是线程安全的容器,在每个线程中都各自取出list中第一个元素加50次，我们期望的值是100，经过运行后，值可能不是100，就存在线程安全性问题

public static void count() {
        List<Integer> list = new ArrayList<>();
        list.add(0);
        Thread thread1 = new Thread(new Task(list));
        Thread thread2 = new Thread(new Task(list));
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.get(0));
    }

    public static class Task implements Runnable {
        List<Integer> list;

        public Task(List<Integer> list) {
            this.list = list;
        }

        @Override
        public void run() {
            for (int i = 0; i < 50; i++) {
                int value = list.get(0);
                list.set(0, ++value);
            }
        }
    }

线程活跃性问题

线程活跃性问题，死锁，弱响应性，饥饿，活锁，丢失的信号等

死锁

当两个以上的运算单元，双方都在等待对方停止运行，以获取系统资源，但是没有一方提前退出时，就称为死锁。

死锁实例

public static void deadlock() {
        String sourceA = "A";
        String sourceB = "B";

        Thread thread1 = new Thread(new DeadlockTask(sourceA,sourceB));
        Thread thread2 = new Thread(new DeadlockTask(sourceB,sourceA));

        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static  class DeadlockTask implements Runnable{
        private String first;
        private String sec;
        public DeadlockTask(String first,String sec){
            this.first = first;
            this.sec = sec;
        }

        @Override
        public void run() {
            synchronized (first){
                System.out.println(Thread.currentThread().getName()+"获取到资源:"+ first);
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (sec){
                    System.out.println(Thread.currentThread().getName()+"获取到资源:"+ sec);
                }
            }
        }
    }

造成死锁有几个因素，禁止抢占、持有和等待、互斥、循环等待，只要打破其中一个条件就不会产生死锁，java中减少在锁嵌套，超时等待获取锁等。

死锁检测手段

1.用 jstack <pid>工具转存stack信息，进行检测

jstack

2.用jvisualvm 图形化工具查看

jvisualvm

饥饿

在多线程环境中，线程永远轮不到cpu时间片，一直处于等待状态，这个不好演示，也不好检测，以下程序演示了设置线程优先级，避免饥饿就是尽量减少线程优先级设置。

public static void lockHunger(){
        Thread thread1 = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("A");
            }
        });
        thread1.setPriority(Thread.MIN_PRIORITY);
        Thread thread2 = new Thread(()->{
            System.out.println("B");
        });
        thread2.setPriority(Thread.MAX_PRIORITY);
        
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

弱响应性

cpu大量时间在处理其他任务，而对某些线程调度时间较少，导致响应缓慢，缓解办法，就是把响应较慢的线程优先级设置高些。

活锁

线程并没有阻塞，而是不断重试相同的操作，但是总是失败，一直处于这种尴尬的状态，避免的操作，增加重试次数限制机制。

实例代码中，线程尝试去对状态值经行修改，然后做一次db交互。

    private static void livelock() {
        final AtomicInteger status = new AtomicInteger();
            Thread thread = new Thread(()->{
                while(status.getAndAdd(0)==0){
                    System.out.println("尝试修改状态.");
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("做一次DB交互，保存状态值。");
            },"活锁测试.");
        thread.start();
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

丢失的信号

给线程一个可预期的信号值，然后让这个线程继续下面的，但是没有得到这个信号，导致的问题。

测试实例，thread1设置信号，thread2根据信号执行任务，由于信号线程的执行无法预知，虽然thread1先调用start()，但是很可能thread2得不到预期的值，避免程序，在thread2中while等待，将不会产生这个问题。

    private static void lostSemaphore() {
        final AtomicBoolean semaphore = new AtomicBoolean();
        Thread thread1 = new Thread(() -> {
            System.out.println("设置信号量");
            semaphore.set(true);
        }, "设置信号量。");

        Thread thread2 = new Thread(() -> {
            if (semaphore.get()) {
                System.out.println("继续我的任务。");
            }
        }, "接受信号量。");
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }