Java多线程和高并发学习笔记4

最新推荐文章于 2024-08-01 15:33:26 发布

101之歌

最新推荐文章于 2024-08-01 15:33:26 发布

阅读量100

点赞数

分类专栏：多线程和高并发

本文链接：https://blog.csdn.net/qxf1374268/article/details/116098391

版权

多线程和高并发专栏收录该内容

10 篇文章 0 订阅

订阅专栏

线程的基本概念

程序：是指令和数据的有序集合，其本身没有任何运行的含义，就是一个静态的概念
进程：进程则是执行程序的一次执行过程，它是一个动态的概念，是系统资源分配的单位
线程：通常是一个进程里面可以包含多个线程，线程是CPU调度和执行的单位

PS：很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多个核心数，如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错觉

下面提几个java线程的概念：
1、main线程被称为主线程，为系统的入口，用于执行整个程序
2、在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的
3、对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
4、线程会带来额外的开销，如cpu调度时间，并发控制开销
5、每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程的创建（Thread，Runnable，Callable）

这块的东西比较简单，直接上代码就好

第一种：继承Thread类，重写run方法，使用start方法调用

package thread2;

public class ThreadDemo extends Thread{
    public void run() {
        System.out.println("thread run");
    }

    public static void main(String[] args) {
        ThreadDemo demo = new ThreadDemo();
        // 线程不一定立即执行，cpu调度安排
        demo.start();
    }
}

举个小例子，多线程下载图片：

package thread2;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;

public class DownLoadImgByThread extends Thread {
    private final String url;
    private final String name;

    public DownLoadImgByThread(String url, String name) {
        this.url = url;
        this.name = name;
    }

    public void run() {
        WebDownLoader webDownLoader = new WebDownLoader();
        webDownLoader.download(url, name);
        System.out.println("下载了文件名称为" + name);
    }

    public static void main(String[] args) {
        DownLoadImgByThread thread1 = new DownLoadImgByThread("https://t7.baidu.com/it/u=737555197,308540855&fm=193&f=GIF", "01.gif");
        DownLoadImgByThread thread2 = new DownLoadImgByThread("https://t7.baidu.com/it/u=737555197,308540855&fm=193&f=GIF", "02.gif");
        DownLoadImgByThread thread3 = new DownLoadImgByThread("https://t7.baidu.com/it/u=737555197,308540855&fm=193&f=GIF", "03.gif");

        thread1.start();
        thread2.start();
        thread3.start();
    }


    public static class WebDownLoader {
        public void download(String url, String name) {
            try {
                FileUtils.copyURLToFile(new URL(url), new File(name));
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("file not find or url not find");
            }
        }
    }
}

实现Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类，调用start方法

package thread2;

public class ThreadDemo2 implements Runnable {
    @Override
    public void run() {
        System.out.println("run thread");
    }

    public static void main(String[] args) {
        ThreadDemo2 demo2 = new ThreadDemo2();
        Thread thread = new Thread(demo2);
        thread.start();
    }
}

小结：Thread和Runnable接口的区别在于，Thread只能是继承，也就是说只有单继承性，而Runnable接口就比较灵活，方便同一个对象被多个线程使用

并发问题

我们先来看一个例子，多个线程抢占一个资源：

package thread2;

import java.util.concurrent.TimeUnit;

public class ThreadDemo3 implements Runnable {
    private int num = 10;

    @Override
    public void run() {
        while (num > 0) {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 拿到了第" + num-- + "个资源");
        }
    }

    public static void main(String[] args) {
        ThreadDemo3 threadDemo3 = new ThreadDemo3();
        new Thread(threadDemo3, "1").start();
        new Thread(threadDemo3, "2").start();
        new Thread(threadDemo3, "3").start();
    }
}

结果如下：
在这里插入图片描述
我们会发现，第5个资源，会在同一时间被2个线程同时拿到，这个是我们不想要看到的情况

实现Callable接口，需要返回值类型，重写call方法，需要抛出异常，创建目标对象，创建执行服务，提交执行，获取结果，关闭服务

代码如下：

package thread2;

import java.util.concurrent.*;

public class CallableDemo implements Callable<Boolean> {

    @Override
    public Boolean call() {
        System.out.println("run callable thread");
        return true;
    }

    public static void main(String[] args) {
        CallableDemo callableDemo = new CallableDemo();
        CallableDemo callableDemo2 = new CallableDemo();
        CallableDemo callableDemo3 = new CallableDemo();
        // 创建线程池
        ExecutorService service = Executors.newFixedThreadPool(3);
        // 提交线程
        Future<Boolean> result = service.submit(callableDemo);
        Future<Boolean> result2 = service.submit(callableDemo2);
        Future<Boolean> result3 = service.submit(callableDemo3);
        try {
            // 获取执行结果
            System.out.println(result.get());
            System.out.println(result2.get());
            System.out.println(result3.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            service.shutdown();
        }
    }
}

结果如下：
在这里插入图片描述

Lambda表达式
作用：避免匿名内部类定义过多，其实质属于函数式编程的概念，可以使代码更加简介，去掉了一堆没有意义的代码，只留下核心的逻辑

函数式接口：任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口，对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

package thread2;

public class LambdaDemo {
    /**
     * 静态内部类
     */
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();

        ILike like2 = new Like2();
        like2.lambda();

        /*
        局部内部类
         */
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }

        ILike like3 = new Like3();
        like3.lambda();

        /*
        匿名内部类：没有类的名称，必须通过接口或者父类实现
         */
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };

        like.lambda();

        /*
        lambda表达式
         */
        like = () -> System.out.println("i like lambda5");
        like.lambda();
    }
}

/**
 * 函数式接口
 */
interface ILike {
    void lambda();
}

/**
 * 普通实现类
 */
class Like implements ILike {

    @Override
    public void lambda() {
        System.out.println("i like lambda");
    }
}

函数式接口->静态内部类->局部内部类->匿名内部类->lambda表达式

线程状态

创建状态：new方法调用的时候
就绪状态：调用start方法，线程进入就绪状态，但是不是立即执行，需要等待cpu的调度
阻塞状态：当调用sleep，wait或者同步锁定时，线程进入阻塞状态，只有等阻塞状态解除后，才会重新进入就绪状态，等待cpu调度执行
运行状态：进入运行状态，线程才开始真正的执行
死亡状态：线程中断或者结束。一旦进入死亡状态，就不能再次启动

线程方法
setPriority：更改线程的优先级
sleep：在指定的毫秒数让当前正在执行线程休眠
join：插入一个线程
yield：暂定当前正在执行的线程对象，并执行其他线程
interrupt：中断线程，尽量不要用
isAlive：测试线程是否处于活动状态

停止线程：不推荐使用stop或者destroy方法，可以使用一个标志位进行终止，当前flag=false时，则终止线程的运行，或者让线程自己运行完成后停止

下面的例子就是线程停止的例子：

package thread2;

import java.util.concurrent.TimeUnit;

public class ThreadDemo4 implements Runnable {
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("thread is running" + i++);
        }
    }

    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        ThreadDemo4 demo4 = new ThreadDemo4();
        Thread thread = new Thread(demo4);
        thread.start();

        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        for (int i = 0; i < 1000; i++) {
            if (i == 900) {
                demo4.stop();
                System.out.println("stop");
            }
        }
    }
}

线程休眠：sleep可以使线程休眠，里面的时间就是指定当前线程阻塞的毫秒数，每个对象都有一个锁，sleep不会释放锁

线程礼让

让当前正在执行的线程暂停，但不阻塞
让线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功，看cpu心情
我们来看个例子：

package thread2;

public class YieldDemo implements Runnable {
    public static void main(String[] args) {
        YieldDemo demo = new YieldDemo();
        new Thread(demo, "a").start();
        new Thread(demo, "b").start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "停止执行");
    }
}

运行结果如下：
在这里插入图片描述
如果没有yield，按理就应该是a线程先执行，然后a线程执行完成后，b线程再开始执行，但是因为a线程执行之后，执行了yield以后，a线程会让出cpu，重新回到就绪状态，这个时候cpu就又会重新去选择a和b之间的一个线程执行。

线程插队

join可以使线程插队，当前线程会等待join的线程执行完成后，再接着执行

例子如下：

package thread2;

public class JoinDemo implements Runnable {
    public static void main(String[] args) {
        JoinDemo demo = new JoinDemo();
        Thread thread = new Thread(demo);
        thread.start();

        for (int i = 0; i < 50; i++) {
            if (i == 25) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("main " + i);
        }
    }

    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("join " + i);
        }
    }
}

运行结果如下：
在这里插入图片描述
我们可以看到，当主线程的循环执行到24的时候，我们的join生效了，让另一个线程加入了进来，主线程就处于阻塞状态，直到另一个线程执行完成以后，主线程才开始继续执行

线程优先级

java提供了一个线程调度器来控制程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行

线程优先级用数字表示，范围从1~10


    /**
     * The minimum priority that a thread can have.
     */
    public final static int MIN_PRIORITY = 1;

   /**
     * The default priority that is assigned to a thread.
     */
    public final static int NORM_PRIORITY = 5;

    /**
     * The maximum priority that a thread can have.
     */
    public final static int MAX_PRIORITY = 10;

我们可以使用以下方式改变或获取优先级

thread.setPriority(1);
thread.getPriority();

优先级的设定建议在start方法之前
优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，这都是看cpu的调度

守护线程（daemon线程）

线程分为用户线程守护线程
虚拟机必须确保用户线程执行完成完毕
虚拟机不用等待守护线程执行完毕（如：后台记录操作日志，监控内存，垃圾回收等）

线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问的冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入了锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。但是会存在下面的问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先级倒置，引起性能问题

同步方法

synchronized关键字，它包含两种方法：synchronized方法和synchronized块
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

Lock锁

从jdk5.0开始，Java提供了更加强大的线程同步机制----通过显式定义同步锁对象来实现同步，同步锁使用Lock对象充当

代码如下：

package thread2;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockDemo implements Runnable {
    int ticketNums = 10;
    private final Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    ticketNums--;
                    System.out.println(ticketNums);
                } else {
                    break;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        LockDemo demo = new LockDemo();
        new Thread(demo, "1").start();
        new Thread(demo, "2").start();
        new Thread(demo, "3").start();
    }
}

运行结果：
在这里插入图片描述

Synchronized和Lock的对比

Lock是显式锁（需要手动开启和关闭），synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好，并且具有更好的扩展性
优先使用顺序：
Lock > 同步代码块（已经进入了方法题，分配了相应资源） > 同步方法（在方法体之外）

线程协作

Java提供了几个方法解决线程之间的通信问题

wait 表示线程会一直等待，直到其他线程通知，与sleep不同，会释放锁
notify 唤醒一个处于等待状态的线程
notifyAll 唤醒同一个对象上所有调用wait方法的线程，优先级别高的线程优先调度
这些方法都只能在同步方法或者同步代码块中使用，否则会抛异常

解决方式1
并发协作模型：生产者/消费者模型
生产者负责生产数据，消费者负责处理数据，消费者不能直接使用生产者的数据，他们之间有一个缓冲区，生产者将生产好的数据放入缓冲区，消费者从缓冲区中拿出数据

例子如下：
首先创建一个商品，我们起名叫Chicken

package thread2;

public class Chicken {
    int id;

    public Chicken(int id) {
        this.id = id;
    }
}

然后我们创建一个缓冲区容器，我们起名叫Container

package thread2;

public class Container {
    Chicken[] chickens = new Chicken[10];
    int count = 0;

    public synchronized void push(Chicken chicken) {
        if (count == chickens.length) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        chickens[count] = chicken;
        count++;

        this.notifyAll();
    }

    public synchronized Chicken pop() {
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();

        return chicken;
    }
}

然后我们创建我们自己的生产者和消费者

package thread2;

public class Producer extends Thread {
    Container container;

    public Producer(Container container) {
        this.container = container;
    }

    public void run() {
        for (int i = 1; i < 100; i++) {
            container.push(new Chicken(i));
            System.out.println("生产了" + i);
        }
    }
}

package thread2;

public class Consumer extends Thread{
    Container container;

    public Consumer(Container container) {
        this.container = container;
    }

    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("消费了" + container.pop().id);
        }
    }

}

最终再来一个测试类

package thread2;

public class Test {
    public static void main(String[] args) {
        Container container = new Container();
        new Producer(container).start();
        new Consumer(container).start();
    }
}

结果如下：

在这里插入图片描述

解决方式2
生产者/消费者模型信号灯法，定义一个信号灯用来判断什么时候开始进行生产，什么时候进行消费

代码如下：

package thread2;

public class TestSignal {
    public static void main(String[] args) {
        Tv tv = new Tv();
        new Player(tv).start();
        new Watcher(tv).start();
    }
}

class Player extends Thread {
    Tv tv;

    public Player(Tv tv) {
        this.tv = tv;
    }

    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("节目");
            } else {
                this.tv.play("广告");
            }
        }
    }

}

class Watcher extends Thread {
    Tv tv;

    public Watcher(Tv tv) {
        this.tv = tv;
    }

    public void run() {
        for (int i = 0; i < 20; i++) {
            tv.watch();
        }
    }
}

class Tv {
    String voice;
    boolean flag = true;

    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("演员表演了" + voice);
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }

    public synchronized void watch() {
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观众观看了" + voice);
        this.notifyAll();
        this.flag = !this.flag;
    }
}

结果如下：
在这里插入图片描述

线程池

经常创建和销毁，使用量特别大的资源，比如并发情况下的线程，对性能影响很大，所以我们可以提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁，实现重复利用。

线程池的使用主要有两个：
ExecutorService：真正的线程池接口
Executors：工具类，线程池的工厂类，用于创建并返回不同类型的线程池

简单的例子如下：

package thread2;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        service.execute(new P1());
        service.execute(new P1());
        service.execute(new P1());
        service.execute(new P1());
        service.shutdown();
    }
}

class P1 implements Runnable {

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