Java之多线程学习笔记

锐行织梦者

已于 2022-05-15 16:06:43 修改

阅读量274

点赞数

分类专栏： Java基础学习笔记文章标签： java 学习开发语言

于 2022-05-06 22:09:45 首次发布

本文链接：https://blog.csdn.net/Tian208/article/details/124609807

版权

Java基础学习笔记专栏收录该内容

17 篇文章 0 订阅

订阅专栏

文章目录

- Java之多线程学习代码

多线程学习

概念

多线程（multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程，进而提升整体处理性能。具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器

学习场景及代码

多线程创建方法：

1.继承Thread
2.实现Runnable接口
3.实现Callable接口

1. 继承Thread类，重写run的方法

① 注意

a.调用run(）方法：只有主线程一条执行路径；
b.调用start()方法：多条执行路径，主线程和子线程并行交替执行

② 练习代码

package multithreading.demo_thread;
//创建线程的方式1：
/**
 * 继承Thread类，重写run的方法，
 *
 */
//总结：注意：线程开启不一定立即执行，由CPU调度执行

public class TestThread01 extends Thread{
    @Override
    public void run(){
        //run方法线程体
        for(int i=0;i<20;i++){
            System.out.println("线程--"+i+"已经开启！");
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        TestThread01 testThread01=new TestThread01();
        //调用run()方法开启线程-先走run方法的程序
        //testThread01.run();
        //调用start()方法开启线程-一起开启的
        testThread01.start();
        for(int i=0;i<20;i++)
        {
            System.out.println("我在学习多线程"+i);
        }
    }
}

2.练习Thread，实现多线程同步下载图片

package multithreading.demo_thread;

import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TestThread02 extends Thread {
    private String url;//网络图片地址
    private String name;//保存的文件名

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

    /**
     * 下载图片的执行体
     */
    @Override
    public void run() {
        WebDownLoader webDownLoader=new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下载了文件，文件名为："+name);
    }

    /**
     *  启动多线程下载图片
     * @param args
     */
    public static void main(String[] args) {
        String url="https://redfireant.cn:8443/uploadfile/cover/220327f89bafdf-39cc-4cf2-9185-18b0b45ba976.jpg";
        String name1="test_02_1.jpg";
        String name2="test_02_2.jpg";
        String name3="test_02_3.jpg";
        TestThread02 testThread02T1=new TestThread02(url,name1);
        TestThread02 testThread02T2=new TestThread02(url,name2);
        TestThread02 testThread02T3=new TestThread02(url,name3);
        //启动(不是先后执行的，是同时执行的)
        testThread02T1.start();
        testThread02T2.start();
        testThread02T3.start();
    }
}
class WebDownLoader{
    //下载方法
    public void downloader(String url,String name){
        System.out.println(url);
        //拷贝一个网页文件到一个文件
        try {
            FileUtils.copyURLToFile(new URL(url),new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法异常！");
        }
    }
}

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

package multithreading.demo_thread;
//创建线程方式② ：调用Runnable接口，重写run方法，执行线程需要丢入Runnable接口实现类，调用start方法
/**
 * 因为java单继承的局限性，推荐使用Runnable
 *
 * 单继承：一种继承机制。其中每个子类只能继承单一的超类。
 */
public class TestThread03 implements Runnable{

    @Override
    public void run() {
        //run方法线程体
        for(int i=0;i<100;i++){
            System.out.println("线程--"+i+"已经开启！");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread03 testThread03=new TestThread03();
        //创建线程对象，通过线程对象来开始我们的线程,代理
//        Thread thread=new Thread(testThread03,"小明");//本质上是一样的
//        thread.start();//实现效果依旧为同时运行的
        for(int i=0;i<5;i++)
        {
            System.out.println("我在学习多线程"+i);
            Thread thread1=new Thread(testThread03, String.valueOf(i));//本质上是一样的
            thread1.start();//实现效果依旧为同时运行的
            try {
                thread1.join();
                System.out.println("已中止");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }
}

4. 练习Thread，实现多线程同步下载图片

package multithreading.demo_thread;


import org.apache.commons.io.FileUtils;

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

//练习Thread，实现多线程同步下载图片
public class TestThread04 implements Runnable {
    private String url;//网络图片地址
    private String name;//保存的文件名

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

    /**
     * 下载图片的执行体
     */
    @Override
    public void run() {
        WebDownLoader webDownLoader=new WebDownLoader();
        webDownLoader.downloader(url,name);
        System.out.println("下载了文件，文件名为："+name);
    }

    /**
     *  启动多线程下载图片
     * @param args
     */
    public static void main(String[] args) {
        String url="https://redfireant.cn:8443/uploadfile/cover/220327f89bafdf-39cc-4cf2-9185-18b0b45ba976.jpg";
        String name1="test_02_1.jpg";
        String name2="test_02_2.jpg";
        String name3="test_02_3.jpg";
        TestThread04 testThread04T1=new TestThread04(url,name1);
        TestThread04 testThread04T2=new TestThread04(url,name2);
        TestThread04 testThread04T3=new TestThread04(url,name3);
        //启动(不是先后执行的，是同时执行的)//代理启动
        new Thread(testThread04T1).start();
        new Thread(testThread04T2).start();
        new Thread(testThread04T3).start();
    }
}

5.多个线程操作同一个对象

package multithreading.demo_thread;

/**
 * 多个线程操作同一个对象
 */
//买火车票的例子
    //发现问题：多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread05 implements Runnable{
    //票数
    private int ticketNums =10;
    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第\u3000\u3000"+ticketNums--+"张票");
            }

    }

    public static void main(String[] args) {
        TestThread05 testThread05=new TestThread05();

        new Thread(testThread05,"小明").start();
        new Thread(testThread05,"小张").start();
        new Thread(testThread05,"黄牛").start();
    }
}

6. 线程分为用户线程和守护线程

package multithreading.state;

/**
 * 线程分为用户线程和守护线程
 * 1.虚拟机必须确保用户线程执行完毕；
 * 2.虚拟机不用等待守护线程执行完毕
 * 如，后台记录操作日志，监控内存，垃圾回收等等
 */
//测试守护线程
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("上帝保佑这你！");
        }
    }
}



//你
class You implements Runnable{

    @Override
    public void run() {
        for(int i=0;i<36500;i++){
            System.out.println("你一生都开心的活着！");
        }
        System.out.println("GoodBye World!");
    }
}

7.测试线程的优先级

注意：
优先级

package multithreading.state;

/**
 * 测试线程的优先级
 */
public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"主线程的优先级为-->"+Thread.currentThread().getPriority());
        MyPriority myPriority=new MyPriority();

        Thread t1 =new Thread(myPriority);
        Thread t2 =new Thread(myPriority);
        Thread t3 =new Thread(myPriority);
        Thread t4 =new Thread(myPriority);
        Thread t5 =new Thread(myPriority);
        Thread t6 =new Thread(myPriority);
        //线程的优先级不一定高的先跑
        /*
        1-10------>超出会报错
         */
        //先设置优先级再启动
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);
        t4.start();
        t5.setPriority(-1);//会报错
        t5.start();
        t6.setPriority(11);
        t6.start();
    }
}
class MyPriority implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程的优先级为-->"+Thread.currentThread().getPriority());
    }
}

线程状态

创建状态、就绪状态、阻塞状态、运行状态、死亡状态

线程方法：

setPriority(int newPriority):更改线程的优先级
static void sleep(long millis):在指定的毫秒数内让当前正在执行的线程休眠
void join() :等待该程序终止
static void yield"暂停当前正在执行的线程对象，并执行其他线程
void interrupt():中断线程，别用这个方式
boolean isAlive()：测试线程是否处于活动状态

*** 不建议使用JDK提供stop(),destroy()的方法停止线程***

8.观察测试线程的状态

package multithreading.state;

/**
 * 观察测试线程的状态
 */
public class TestState {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            for (int i=0;i<5;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                System.out.println("/");
            }
        });
        /**
         * 观察状态
         */
        Thread.State state=thread.getState();
        System.out.println(state);//NEW

        /**
        观察启动后
         */
        thread.start();//启动线程
        state=thread.getState();
        System.out.println(state);//Run

        /**
         * 只要线程不终止，就一直是输出状态
         *
         */
        while (state != Thread.State.TERMINATED){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state=thread.getState();//更新线程状态
            System.out.println(state);
            //死亡后的线程则不能执行了
//            thread.start();//会报异常
        }
    }

}

9.测试礼让线程

package multithreading.state;

/**
 * 测试礼让线程
 */
//礼让不一定成功
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield=new MyYield();

        new Thread(myYield,"a").start();
        /*
        aabb礼让不成功
        abab礼让成功
         */
        new Thread(myYield,"b").start();

    }

    static class MyYield implements Runnable{

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

线程休眠

10.模拟网络延时

package multithreading.sleep;

import multithreading.demo_thread.TestThread05;

/**
 * 模拟网络延时:放大问题的发生性
 */
public class TestSleep implements Runnable{
    //票数
    private int ticketNums =10;
    @Override
    public void run() {
        while(true){
            if(ticketNums<=0){
                break;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"拿到了第\u3000\u3000"+ticketNums--+"张票");
        }

    }

    public static void main(String[] args) {
        TestSleep testSleep=new TestSleep();

        new Thread(testSleep,"小明").start();
        new Thread(testSleep,"小张").start();
        new Thread(testSleep,"黄牛").start();
    }
}

11.模拟倒计时

package multithreading.sleep;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 模拟倒计时
 */
public class TestSleep1 {
    public static void main(String[] args) {
//        tenDown();
        while (true){
            try {
                //打印当前系统时间
                Date startTime =new Date(System.currentTimeMillis());//获取当前系统时间
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(startTime));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 10秒倒计时
     */
    public static void tenDown(){
        int num=10;

        while (true){
            try {
                Thread.sleep(1000);
                System.out.println(num--);
                if(num<=0){
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

11.不安全的取钱：两个人去银行取钱，账号

package multithreading.syn;

/**
 * 不安全的取钱
 * 两个人去银行取钱，账号
 */
public class UnSafeBank {
    public static void main(String[] args) {
        //账户
        Account account=new Account(1000,"结婚基金");

        //取钱
        Drawing you=new Drawing(account,50,"你");
        Drawing girlFriend=new Drawing(account,100,"女朋友");

        you.start();
        girlFriend.start();
    }
}


//账户
class Account{
    int money;//余额
    String name;//卡名

    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}

//银行：模拟取款
class Drawing extends Thread{
    Account account;//账户
    //取了多少钱
    int drawingMoney;
    //现在手里有多少钱
    int nowMoney;
    //

    public Drawing(Account account,int drawingMoney,String name){
        super(name);
        this.account=account;
      this.drawingMoney=drawingMoney;

    }


    //取钱
//synchronized方法+synchronized块
    @Override
    public  void run() {
        //锁的对象就是变化的量，锁的是增删改的对象
        synchronized (account){


        //判断有没有钱
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够了，取不了");
            return;

        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //卡内余额=余额-你取的钱
        account.money=account.money-drawingMoney;
        //你手里的钱
        nowMoney=nowMoney+drawingMoney;


        System.out.println(this.getName()+"手里的钱"+nowMoney);
            System.out.println(account.name+"余额为："+account.money);
        }
        }
}

12.线程不安全的集合

package multithreading.syn;

import java.util.ArrayList;
import java.util.List;

/**
 * 线程不安全的集合
 */
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                //锁住线程就安全了
                synchronized (list) {
                    list.add(Thread.currentThread().getName());
                } }).start();
        }
        try{
            Thread.sleep(3000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(list.size());
        //偶尔没有1000条数据，就是线程不安全
        /*
        原因：把两个数组添加到同一个位置
         */
    }
}

13.测试JUC安全安全类型的集合

package multithreading.syn;

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 测试JUC安全安全类型的集合
 */
public class TestJUC {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list=new CopyOnWriteArrayList<String>();
        for(int i=0;i<10000;i++){
            new Thread(()->{
                    list.add(Thread.currentThread().getName());
            }).start();

        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(list.size());
    }
}

14 停止线程

package multithreading;

/**
 * 停止线程
 */
//1.建议线程正常停止---》利用次数，不建议死循环
//2.建议使用标志位----》设置一个标志位
//3. 不要使用stop()或者destroy()等过时或者JDK不建议使用的方法
public class ThreadStop implements Runnable{
    //1.设置一个标识位
    private boolean flag=true;

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

    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        ThreadStop te=new ThreadStop();
        new Thread(te).start();
        for(int i=0;i<1000;i++){
            System.out.println("main"+i);
            if(i==900){
                //调用stop方法切换标志位，让线程停止
                te.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

15.测试lock锁—买票

package multithreading.end;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试lock锁---买票
 */
public class TestLock{
    public static void main(String[] args) {
        TestLock2 testLock2=new TestLock2();

        new Thread(testLock2).start();
        new Thread(testLock2).start();
        new Thread(testLock2).start();
    }
}
 class TestLock2 implements Runnable{
    int ticketNums=10;

    //定义lock锁
     private final ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){

            //加锁
            try {
                lock.lock();
                if (ticketNums > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(ticketNums--);
                } else {
                    break;
                }
            }finally {
                //解锁
                lock.unlock();
            }
        }
    }
}

16.推导lambda表达式

如果只包含唯一抽象方法，那么它就是一个函数式接口。

package multithreading.lambda;

/**
 * 推导lambda表达式
 */
public class TestLambda {

    //3.静态内部类
    static class Like2 implements ILike{

        @Override
        public void lambda() {
            System.out.println("I Like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike iLike=new Like();
        iLike.lambda();

        iLike=new Like2();
        iLike.lambda();

        //4.局部内部类
        class Like3 implements ILike{

            @Override
            public void lambda() {
                System.out.println("I Like Lambda3");
            }
        }
        iLike=new Like3();
        iLike.lambda();

        //5.匿名内部类
        iLike=new Like(){
            @Override
            public void lambda() {
                System.out.println("I Like Lambda4");
            }
        };
        iLike.lambda();
        //6.用lambda简化
        iLike =()->{
            System.out.println("I Like Lambda5");
        };
        iLike.lambda();

    }
}
//1.定义一个函数式接口(只包含唯一一个抽象方法)
interface ILike{
    void lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda1");
    }

}

17测试Join方法//想象为插队

package multithreading.state;

/**
 * 测试Join方法//想象为插队
 */
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<10000;i++){
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) {
        //启动我们的线程
        TestJoin testJoin=new TestJoin();
        Thread thread=new Thread(testJoin);
        thread.start();
//
//        //主线程
//        for(int i=0;i<300;i++){
//            System.out.println("main"+i);
//            if(i==100){
//
//                try {
//                    thread.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
//
//        }
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for(int i=0;i<500;i++){
            System.out.println("main"+i);
        }
    }
}

18管程法–>测试：生产者消费者模型–>利用缓冲区解决：管程法

package multithreading.end;

/**
 * 管程法-->测试：生产者消费者模型-->利用缓冲区解决：管程法
 */
//生产者、消费者、产品、缓冲区
public class TestPC {
    public static void main(String[] args) {
        SynContainer synContainer=new SynContainer();
        new Productor(synContainer).start();
        new Consumer(synContainer).start();
    }
}

//生产者
class Productor extends Thread{
    SynContainer container;
    public Productor(SynContainer container){
        this.container=container;
    }
//生产
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {

            container.push(new Chicken(i));
            System.out.println("生产了"+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) {
                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;
    }
}

19 信号灯法–> 测试生产者消费问题2,标志位解

package multithreading.end;

/**
 * 信号灯法--> 测试生产者消费问题2,标志位解决
 */
public class TestPC2 {
    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;
    }

    @Override
    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;
    }

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


//产品-->节目
class TV{
    //演员表演，观众等待 T

    //观众观看，演员等待 F
    String voice;//表演的节目
    boolean flag=true;
    //表演
    public synchronized void play(String voice){
        if(!flag){
            try {
                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;
    }
}

20 线程池

package multithreading.end;

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

/**
 * 线程池
 */
public class TestPool {
    public static void main(String[] args) {
        //1.创建服务，创建线程池
        //newFixedThreadPool：参数为线程池的大小
        ExecutorService executorService= Executors.newFixedThreadPool(10);
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        executorService.execute(new MyThread());
        //2.关闭连接
        executorService.shutdown();
    }

}
class MyThread implements Runnable{

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