java多线程

最新推荐文章于 2023-05-14 20:53:36 发布

C学长

最新推荐文章于 2023-05-14 20:53:36 发布

阅读量218

点赞数

文章标签： java 开发语言 jvm

本文链接：https://blog.csdn.net/weixin_44134930/article/details/127954205

版权

线程是独立执行的路径
在程序运行时即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；
main（）称之为主线程，为系统的入口，用于执行整个程序
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的选后顺序时不能认为的干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制
线程会带来额外的开销，如cpu调度使劲按，并发控制开销
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

继承Thread

/**
 * 多线程测试
 * @author xcz
 */
public class TestThread1 extends Thread {  //先继承Tread类
    @Override
    public void run() {  //重写run方法
        for (int i = 0; i < 2000; i++) {
            System.out.println("running"+i);
        }
    }

    public static void main(String[] args) {
        TestThread1 testThread1 = new TestThread1(); //将TestThread1实例化
        testThread1.start();  //使用start方法开启多线程
        for (int i = 0; i < 2000; i++) {
            System.out.println("waiting"+i);
        }
    }
}

实现runnable接口

public class TestThread3 implements Runnable {
    @Override
    public void run() {  //重写run方法
        for (int i = 0; i < 2000; i++) {
            System.out.println("running" + i);
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread3 testThread3 = new TestThread3(); //将TestThread1实例化
        //床架你线程对象，通过线程对象来开启线程，代理
        Thread thread = new Thread(testThread3);
        thread.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("waiting" + i);
        }
    }

}

runnable本质上就是thread

区别

继承Thread类
- 子类继承Thread类具备多线程能力
- 启动线程：子类对象.start()
- 不建议使用：避免OOP单继承局限性
实现Runnable接口
- 实现接口Runnable具有多线程能力
- 启动线程：传入目标对象+thread对象.start() 推荐使用：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

Callable接口实现

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class Callable implements java.util.concurrent.Callable<Boolean> {

    private String url, name;

    public Callable(String url,String name) {
        this.url = url;
        this.name = name;
    }
    @Override
    public Boolean call() {   //线程创建
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url, name);
        System.out.println("下载了文件：" + name);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Callable testThread2_1 = new Callable("https://tva4.sinaimg.cn/large/008kBpBlgy1gzen37tozjj305i07n3yx.jpg", "01.jpg");
        Callable testThread2_2 = new Callable("https://tva4.sinaimg.cn/large/008kBpBlgy1gxx56b08hij305i07nmx8.jpg", "02.jpg");
        Callable testThread2_3 = new Callable("https://tva4.sinaimg.cn/large/008v6dp8gy1h6eipk1e0ej305i07nt8x.jpg", "03.jpg");

        //调用线程

        //创建执行任务  线程池
        ExecutorService ser = Executors.newFixedThreadPool(3);

        //提交执行
        Future<Boolean> r1 = ser.submit(testThread2_1);
        Future<Boolean> r2 = ser.submit(testThread2_2);
        Future<Boolean> r3 = ser.submit(testThread2_3);

        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();

        //关闭服务
        ser.shutdown();
    }
}

callable 优点
- 可以定义返回值
- 可以爬出异常

步骤

实现Callable接口，需要返回值类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务（new一个线程池）

   //创建执行任务  线程池 线程数为3
        ExecutorService ser = Executors.newFixedThreadPool(3);

提交执行

   Future<Boolean> r1 = ser.submit(testThread2_1);

获取结果

boolean rs1 = r1.get();

关闭服务

ser.shutdown();

Lamda表达式

避免匿名内部内定义过多
代码简介
留下核心代码

静态代理模式

public class StaticProxy {
    public static void main(String[] args) {
        new You().HappyMarry();
        new I().HappyMarry();
        //将事物 真实实例放入代理类，代理类会帮真实对象完成一些事物
        new WeddingCompany(new You()).HappyMarry();
        new WeddingCompany(new I()).HappyMarry();
        new Thread(new WeddingCompany(new You())).start();
        new Thread(new WeddingCompany(new I())).start();

    }
}

interface Marry {
    void HappyMarry();
}

//真实角色
class You implements Marry {

    @Override
    public void HappyMarry() {
        System.out.println("marry happy you");
    }
}
class I implements Marry {

    @Override
    public void HappyMarry() {
        System.out.println("marry happy I");
    }
}

//代理角色
class WeddingCompany implements Marry ,Runnable{
    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();

    }

    private void after() {
        System.out.println("婚后");
    }

    private void before() {
        System.out.println("婚前");
    }

    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            this.HappyMarry();
        }
    }
}

线程的状态

Sleep线程睡眠

sleep（时间）指定当前线程阻塞的毫秒数
sleep存在异常interruptedException
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

yield线程礼让

礼让线程，让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让cpu重新调度，礼让不一定成功

package state;

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();

        new Thread(myYield, "A").start();
        new Thread(myYield, "B").start();
    }
}

class MyYield implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始");
        Thread.yield();  //礼让
        System.out.println(Thread.currentThread().getName()+"线程停止");
    }
}

礼让成功

join

join合并线程，待此线程执行完成后，再执行其他线程，其他线程阻塞
插队

priority优先级

package state;

//测试线程的优先级
public class TestPriority {
    public static void main(String[] args) {

//主线程优先级
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());

        MyPriority myPriority = new MyPriority();
        Thread thread1 = new Thread(myPriority);
        Thread thread2 = new Thread(myPriority);
        Thread thread3 = new Thread(myPriority);
        Thread thread4 = new Thread(myPriority);
        Thread thread5 = new Thread(myPriority);

        thread1.start();

        thread2.setPriority(Thread.MIN_PRIORITY);
        thread2.start();

        thread3.setPriority(4);
        thread3.start();

        thread4.setPriority(Thread.MAX_PRIORITY);
        thread4.start();

        thread5.setPriority(-1);
        thread5.start();
    }
}

class MyPriority implements Runnable {

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());

    }
}

java提供一个线程调度器来监控程序启动后进入就绪状态的所有线程，线程调度器按照优先级决定应用改调度哪个线程来执行
线程的优先级用数字表示范围从1~10
- Thread.MIN_PRIORITY = 1
- Thread.MAX_PRIORITY = 10
- Thread.MORM_PRIORITY = 5
使用以下方式改变或获取优先级
- getPriority().setPriority(int xxx)

优先级低只是以为着获取调度的概率低，并不是优先级低就不会被调用了，这都是看CPU的调度

性能倒置：优先级低的线程先被执行了，优先级高的反而再等待

daemon守护线程

- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- exp：后台记录操作日志，监控内存，GC

package state;

public class TestDaemon {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//默认是false表示是用户线程，正常的线程都是用户线程

        thread.start();//上帝守护线程启动

        new Thread(you).start();
    }
}

class God implements Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("alive god");
        }
    }
}

class You implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你要幸福啊");
        }
        System.out.println("mortal");
    }
}

并发

线程同步

由于同意进程的多个线程共享一块存储空间，再带来方便的同时，也带来了访问冲突问题，为了保证数据再方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待使用后释放锁即可
一个线程持有锁会导致其他所有需要此锁的线程挂起
在多线程竞争下，加锁，释放锁会导致比较多的上线问切换和调度延时，引起性能问题
如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题

package syn;

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        Thread threadA = new Thread(buyTicket, "AAA");
        Thread threadB = new Thread(buyTicket, "BBB");
        Thread threadC = new Thread(buyTicket, "CCC");

//        threadA.setPriority(Thread.MAX_PRIORITY);
//        threadB.setPriority(Thread.MIN_PRIORITY);
//        threadC.setPriority(Thread.NORM_PRIORITY);
        threadA.start();
        threadB.start();
        threadC.start();

    }
}

class BuyTicket implements Runnable {
    private int ticketNums = 10;
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
      //synchronized   保障了数据的安全
    private synchronized void buy() throws InterruptedException {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        Thread.sleep(1000);

        System.out.println(Thread.currentThread().getName() + "---get---" + ticketNums--);
    }
}

加了同步锁不会出现-1

不加同步锁导致对象操作数据冲突

同步锁保障了数据安全，但是同时同步锁会导致性能的下降

同步锁

由于外卖可以通过private关键字来保证数据对象只能被方法访问，所有外卖只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法：synchronized方法和synchronized块

    private synchronized void buy() throws InterruptedException {

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得改方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，知道该方法返回才释放锁，后面被阻塞的线程才能过得这个锁，继续执行

缺陷：若将一个大的方法声明为synchronized会将影响效率

同步块

同步块 synchronized(Obj){}
Obj称为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步就是this，就是这个对象的本身，或者是class
同步监视器的执行过程
1. 第一个点成访问，锁定同步监视器，执行其中代码
2. 第二个线程访问，锁定同步监视器，执行其中代码，
3. 第一个线程访问完毕，解锁同步监视器
4. 第二和线程访问，发现同步监视器没有锁，然后锁定并访问

死锁

多个线程各自占有一些共享资源，并且等待其他占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生死锁

package deadLock;

public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "g1");
        Makeup g2 = new Makeup(0, "g2");

        g1.start();
        g2.start();
    }
}
//资源A
class Lipstick {

}
//资源B
class Mirror {

}

class Makeup extends Thread {

    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();

    int choice;
    String girlName;

    Makeup(int choice, String girlName) {
        this.choice = choice;
        this.girlName = girlName;
    }

    @Override
    public void run() {
        try {
            makeup();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }


    //互相持有对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
        //嵌套的时候是锁住不放的，因为拿不到第二个所以一直不会释放第一个，顺序写下去是拿到第一个sleep时间一过就释放了
            synchronized (lipstick) {
                System.out.println(this.girlName + "获得口行的锁");
                Thread.sleep(1000);
                synchronized (mirror) {
                    System.out.println(this.girlName + "获得镜子锁");
                }
            }
        } else {
            synchronized (mirror) {
                System.out.println(this.girlName + "获得镜子锁");
                Thread.sleep(1000);
                synchronized (lipstick) {
                    System.out.println(this.girlName + "获得口红的锁");
                }
            }
        }
    }
}

产生死锁的四个必要条件

互斥条件：一个资源每次只能被一个进程使用
请求与保持条件：一个进程因请求资源而阻塞时，对以获得的资源保持不放
不剥夺条件：进程获得的资源，在未使用完之前，不能强行剥夺
循环等待条件：若干进程之间形成一种头尾相接的循环等待条件

以上的四个条件同时满足时才会发生死锁，只要避免其中一个就能避免死锁

Lock 锁

package deadLock;

import java.util.concurrent.locks.ReentrantLock;

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

    }

    private final ReentrantLock lock = new ReentrantLock();

    int ticketNums = 10;

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


        }
    }
}

synchronized与lock的对比

lock是显示锁（手动开启和关闭锁）synchronized是隐式锁，出了作用域就自动释放
lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁JVM将花费较少的时间来调度线程，性能更好，并且有更好的拓展性（提供更多的子类）

优先使用顺序 lock》同步代码块（已经进入了方法体，分配了相应资源）》同步方法（在方法体之外）

ReentrantLock类实现了Lock，它拥有与synchronized想用的并发性和内存语义，在实现线程安全控制中，比较常用的是ReentrantLock，可以显示枷锁，释放锁

线程协作

方法名	作用
wait()	表示线程一直等待，知道其他线程通知，与sleep不同，会释放锁
wait(long timeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait（）方法的线程，优先级别高的线程优先调度

均是Object类方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常

生产者和消费者模式
管程法:建立缓存区

package producer_and_consumer;

//管程法
//生产，消费，缓冲
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Producer(container).start();
        new Consumer(container).start();
    }
}
//生产者
class Producer extends Thread {
    SynContainer container;

    public Producer(SynContainer container) {
        this.container = container;
    }
//生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("生产了" + i + "鸡");
            container.push(new Chicken(i));

        }
    }
}

//消费者
class Consumer extends Thread {
    SynContainer container;

    public Consumer(SynContainer container) {

        this.container = container;
    }
//消费
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            System.out.println("消费了" + container.pop().id + "只鸡");
        }
    }
}
//产品
class Chicken {
    int id;  //产品编号

    public Chicken(int id) {
        this.id = id;
    }
}
//缓冲区
class SynContainer {
    //需要一个容器的大小
    Chicken[] chickens = new Chicken[10];
    //容器计数器
    int count = 0;

    //生产者放入产品
    public synchronized void push(Chicken chicken) {
        //如果容器满了，就要等待消费者消费
        if (count == chickens.length) {
            //通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        //如果没有满，外卖就需要丢入产品
        chickens[count++] = chicken;
        //可以通知消费者消费了
        this.notifyAll();
    }

    public synchronized Chicken pop() {
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        count--;
        Chicken chicken = chickens[count];
        this.notifyAll();
        return chicken;
    }
}

- 信号灯法

package producer_and_consumer;

import lombok.Data;

//测试生产者消费者问题2：信号灯法，标志位
public class TestPC2 {
    public static void main(String[] args) {
        TV tv = new TV();
        new Player(tv).start();
        new Watcher(tv).start();

    }
}

//生产者   演员
//@Data
class Player extends Thread {
    TV tv;

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

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            if (i % 2 == 0) {
                this.tv.play("bilibili");
            } else {
                this.tv.play("youtube");
            }
        }
    }
}
//@Data
//消费者   观众
class Watcher extends Thread {
    TV tv;

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

    @Override
    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) {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        System.out.println("演员表演了：" + voice);
        //通知观众观看
        this.notifyAll();//通知唤醒
        this.voice = voice;
        this.flag = !this.flag;
    }

    //观看
    public synchronized void watch() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        if (flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("观看了" + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

本质上信号法就是容量为1的管程法

线程池

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池子中。**可以避免频繁创建销毁、实现重复利用。**类似生活中的交通工具
好处：
- 提高响应速度（减少了创建新线程的的时间）
- 降低资源消耗（重复利用线程池，不需要每次都创建）
- 便于线程管理
  - corePoolSize：核心池的大小
  - maxinumPoolSize：最大线程数
  - keepAliveTime：线程没有任务时最多保持多长时间后会终止
ExecutorService：真正的线程池接口。常见积累ThreadPoolExecutor
- void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
- <T>Future<T> submit(Callable<T> task):执行任务，有返回值，一般用来执行Callable
- void shutdown():关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池

package pool;

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

public class TestPool {
    public static void main(String[] args) {
        //创建服务，创建线程池
        //newFixedThreadPool参数为 线程池大小
        ExecutorService service = Executors.newFixedThreadPool(10);

        //执行
        service.execute(new Mythread());
        service.execute(new Mythread());
        service.execute(new Mythread());
        service.execute(new Mythread());
         //关闭连接
        service.shutdown();

    }
}

class Mythread implements Runnable {

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

线程池执行步骤

创建线程池设置线程池的大小
执行execute（内置类的实例）
关闭连接

总结

线程创建的三种方法

继承Thread 重写 run方法
实现Runnable接口重写 run方法
实现Callable接口重写call方法 return一个值

调用

thread newXXX().start()
Runnable 需要启动代理类 new Thread(new xxx)).start()
FutureTask<T> ft=new FutureTask(new xxx());

C学长

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java多线程

线程创建的三种方法继承Thread 重写 run方法实现Runnable接口重写 run方法实现Callable接口重写call方法 return一个值调用Runnable 需要启动代理类 new Thread(new xxx)).start()
复制链接

扫一扫