多线程学习笔记

最新推荐文章于 2024-04-30 12:12:17 发布
最新推荐文章于 2024-04-30 12:12:17 发布
阅读量56 收藏
点赞数
文章标签： java 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zlq825/article/details/133500909
版权

一、线程简介


1.1、程序&进程&线程

 1. 程序：指令和数据的有序集合，本身没有任何运行的含义，是一个静态概念
 2. 进程：执行程序的一次执行过程，是一个动态概念。是系统资源分配的单位。
 3. 线程：一个进程中包括一个至多个线程。线程是CPU调度和执行的单位。

   注意： 很多线程是模拟出来的，真正的多线程指多个CPU，即多核，如服务器。模拟出来的多线程在同一时间点，CPU只能执行一个代码，因为切换的很快，所以有同时执行的错觉。
普通方法调用和多线程

1.1.1 普通方法调用和多线程

1.1.2 进程

概念：而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义。线程是CPU调度和执行的的单位。

本章核心概念

  • 线程是独立的执行路径
  • 程序运行时，即使没有创建线程，后台也有多个线程如：主线程、gc线程
  • main() 称之为主线程，为系统的入口，用于执行整个程序
  • 如果开辟了多个线程，线程运行由调度器安排，先后顺序不能人为干预
  • 对于同一份资源操作时，会存在资源抢夺问题，需要加入并发控制
  • 线程会带来额外的开销，如CPU调度时间，并发控制开销
  • 每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

二、线程的创建

Thread、Runnable、Callable

三种创建方式

2.1 继承Thread类

继承Thread类，重新run方法，调用start方法

注意:线程不一定立即执行，由CPU调度执行

package com.thread.inheritThread;

//创建线程方式一：继承Thread类，重写run方法，调用start开启线程
/*
总结：
1、线程开启不一定立即执行，由cpu调度执行
 */
public class InheritThread01 extends Thread {
    @Override
    public void run() {
//run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在run方法中------" + i);
        }
    }

    public static void main(String[] args) {
//创建一个线程对象，调用start方法开启线程
        InheritThread01 inheritThread01 = new InheritThread01();
        inheritThread01.start();
//        main方法主线程
        for (int i = 0; i < 30; i++) {
            System.out.println("我在主线程学习----" + i);
        }
    }
}

2.1.1 网图下载

package com.thread.inheritThread;

import org.apache.commons.io.FileUtils;

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

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

    public InheritThread02(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);
    }

    public static void main(String[] args) {
        InheritThread02 t1 = new InheritThread02("https://img1.baidu.com/it/u=4211764839,135267177&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=313", "001.jpeg");
        InheritThread02 t2 = new InheritThread02("https://img2.baidu.com/it/u=1233095065,2157239764&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "002.jpeg");
        InheritThread02 t3 = new InheritThread02("https://img1.baidu.com/it/u=297267401,1836041528&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500", "003.jpeg");
        InheritThread02 t4 = new InheritThread02("https://lmg.jj20.com/up/allimg/1113/0F220091915/200F2091915-14-1200.jpg", "004.jpg");
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

2.2 实现Runnable接口

方式二：实现Runnable接口

  1. 创建线程类声明实现Runnable接口
  2. 重写run()方法
  3. 创建Runnable接口实现类对象
  4. new一个Thread类对象，并将线程的实例化对象作为参数传递
  5. 调用start方法开启线程

package com.thread.implementRunnable;

import com.thread.inheritThread.InheritThread01;

//创建线程方式2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
public class Runnable001 implements Runnable {

    @Override
    public void run() {
//run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我看代码------" + i);
        }
    }

    public static void main(String[] args) {
//创建runnable接口的实现类对象
        Runnable001 runnable001 = new Runnable001();
//        创建线程对象，通过线程对象来开启我们的线程，代理
//        Thread thread = new Thread(runnable001);
//        thread.start();
        new Thread(runnable001).start();
        for (int i = 0; i < 30; i++) {
            System.out.println("我在主线程学习----" + i);
        }
    }
}

2.2.1 网图下载

package com.thread.implementRunnable;

import org.apache.commons.io.FileUtils;

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

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

    public Runnable02(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);
    }

    public static void main(String[] args) {
        Runnable02 t1 = new Runnable02("https://img1.baidu.com/it/u=4211764839,135267177&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=313", "001.jpeg");
        Runnable02 t2 = new Runnable02("https://img2.baidu.com/it/u=1233095065,2157239764&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "002.jpeg");
        Runnable02 t3 = new Runnable02("https://img1.baidu.com/it/u=297267401,1836041528&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500", "003.jpeg");
        Runnable02 t4 = new Runnable02("https://lmg.jj20.com/up/allimg/1113/0F220091915/200F2091915-14-1200.jpg", "004.jpg");
        new Thread(t1).start();
        new Thread(t2).start();
        new Thread(t3).start();
        new Thread(t4).start();
    }
}

//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

2.2.2 小结

2.3 初识并发问题

  • 多线程同时操作同一个对象
  • 问题：线程不安全，数据紊乱
案例一：抢票
package com.thread.threadconcurrency;

//多个线程同时操作同一个对象
//买火车票的例子
public class SnatchATicket implements Runnable {
    //总票数
    private int tickNums = 10;//tickNums为共享资源，数据会紊乱
    @Override
    public void run() {
        while (true) {
            if (tickNums <= 0) {
                break;
            }
            try {//模拟延时
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿到了第-->" + tickNums-- + "张票");
        }
    }
    public static void main(String[] args) {
        SnatchATicket snatchATicket = new SnatchATicket();

        new Thread(snatchATicket, "张三").start();
        new Thread(snatchATicket, "李四").start();
        new Thread(snatchATicket, "王五").start();
    }
}

//案例一部分结果：多线程同时操作同一对象时，tickNums为共享资源，数据会紊乱

李四拿到了第-->5张票
王五拿到了第-->4张票
李四拿到了第-->2张票
张三拿到了第-->3张票
王五拿到了第-->1张票
李四拿到了第-->0张票
张三拿到了第-->-1张票

案例二：乌龟赛跑

package com.thread.threadconcurrency;

//模拟乌龟赛跑
public class TurtleRace implements Runnable {

    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
//            模拟让兔子休息
            if (Thread.currentThread().getName().equals("兔子") && i % 10 == 0) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            //判断比赛是否结束的标记，调用比赛是否完成方法
            boolean flag = gameOver(i);
            //如果比赛结束了，就停止程序
            if (flag) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "跑了" + i + "步");
        }
    }
    //判断是否完成比赛
    private boolean gameOver(int steps) {
        //判断是否有胜利者
        if (winner != null) {//已经存在胜利者
            return true;
        }
        {
            if (steps == 100) {
                winner = Thread.currentThread().getName();
                System.out.println("winner is " + winner);
                return true;
            }
        }
        return false;
    }
    
    public static void main(String[] args) {
        TurtleRace turtleRace = new TurtleRace();

        new Thread(turtleRace, "兔子").start();
        new Thread(turtleRace, "乌龟").start();
    }
}

//案例二部分结果：

乌龟跑了98步
兔子跑了16步
兔子跑了17步
乌龟跑了99步
兔子跑了18步
winner is 乌龟

注意与案例一区别：这里也是多线程同时操作同一对象，共享的资源为winner，注意winner与案例一中tickNums区别

2.4 实现Callable接口（了解即可）

方式三：实现Callable接口

优点：

  1. 可以定义返回值
  2. 可以抛出异常

package com.thread.implementCallable;

import com.thread.implementRunnable.Runnable02;
import org.apache.commons.io.FileUtils;

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

//线程创建方式三：实现callable接口
/*
可以定义返回值
可以抛出异常
 */

public class Callable001 implements Callable<Boolean> {
    private String url;     //网络图片地址
    private String name;        //保存的文件名
//    有参构造
    public Callable001(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 {
        Callable001 t1 = new Callable001("https://img1.baidu.com/it/u=4211764839,135267177&fm=253&fmt=auto&app=138&f=JPEG?w=500&h=313", "001.jpeg");
        Callable001 t2 = new Callable001("https://img2.baidu.com/it/u=1233095065,2157239764&fm=253&fmt=auto&app=138&f=JPEG?w=800&h=500", "002.jpeg");
        Callable001 t3 = new Callable001("https://img1.baidu.com/it/u=297267401,1836041528&fm=253&fmt=auto&app=138&f=JPEG?w=889&h=500", "003.jpeg");
        Callable001 t4 = new Callable001("https://lmg.jj20.com/up/allimg/1113/0F220091915/200F2091915-14-1200.jpg", "004.jpg");
//        创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
//        提交执行
        Future<Boolean> result1 = ser.submit(t1);
        Future<Boolean> result2 = ser.submit(t2);
        Future<Boolean> result3 = ser.submit(t3);
        Future<Boolean> result4 = ser.submit(t4);
//        获取结果
        Boolean r1 = result1.get();
        Boolean r2 = result2.get();
        Boolean r3 = result3.get();
        Boolean r4 = result4.get();
        System.out.println(r1);
        System.out.println(r2);
        System.out.println(r3);
        System.out.println(r4);
//        关闭服务
        ser.shutdownNow();
    }
}

//下载器
class WebDownloader {
    //下载方法
    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，downloader方法出现问题");
        }
    }
}

2.5 静态代理

  1. 静态代理实现
    • 真实对象和代理对象都要实现同一个接口
    • 代理对象要代理真实角色
  2. 静态代理好处
    • 代理对象可以做很多真实对象做不了的事情
    • 真实对象专注做自己的事情
package com.thread.staticProxy;

/*
静态代理模式总结：
真实对象和代理对象都要实现同一个接口
代理对象要代理真是角色
好处：
    代理对象可以做很多真是对象做不了的事情
    真是对象专注做自己的事情
 */
public class StaticProxy001 {

    public static void main(String[] args) {
        You you = new You();//你要结婚
        
        new Thread(() -> System.out.println("我爱你")).start();
        new WeddingCompany(new You()).HappyMarry();
        
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
    }
}

interface Marry {
    //   人间四大喜事
    //久旱逢甘霖
    //他乡遇故知
    //洞房花烛夜
    //金榜题名
    void HappyMarry();
}

//真是角色，你去结婚
class You implements Marry {
    @Override
    public void HappyMarry() {
        System.out.println("小明结婚了，很开心");
    }
}

//代理角色，帮助你结婚
class WeddingCompany implements Marry {
    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("结婚之前，布置现场");

    }
}

2.6 Lamda表达式

package com.thread.lambda;
//Lamda表达式演变过程

public class Lambda001 {
    //3.静态内部类
    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();

        like = new Like2();
        like.lambda();
//4.局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        like = new Like3();
        like.lambda();
//5.匿名内部类,没类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like.lambda();
//6.lamabda简化
        like = () -> {
            System.out.println("i like lambda5");
        };
        like.lambda();

    }
}

//1.定义一个函数式接口
interface ILike {
    void lambda();
}

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

import javax.swing.plaf.synth.SynthOptionPaneUI;
//接口中方法带参数是，lambda表达式简化
public class Lambda002 {
    public static void main(String[] args) {
        ILove love = null;
        love = (int a, int b) -> {
            System.out.println("i love you1" + a);
        };
//        简化1、去掉参数类型
        love = (a, b) -> {
            System.out.println("i love you1" + a);
        };
//        简化2、简化括号
        love = (a, b) -> {
            System.out.println("i love you1-->" + a);
        };
//简化3：去掉花括号
        love = (a, b) -> System.out.println("i love you1-->" + a);
/*
总结：
1.lambda表达式只能有一行代码的情况下才能简化成为一行，若有多行，那么就用代码块包裹
2.前提是接口为函数式接口：只能有一个方法的接口
3.多个参数也可以去掉参数类型，要去掉就都去掉
 */
        love.love(521, 22);
    }
}
interface ILove {
    void love(int a, int b);
}

2.7 线程状态(五大状态）

2.7.1 线程五大状态：

2.7.2 线程方法：

2.7.2.1 停止线程方法：
  • 不推荐使用JDK提供的stop()、destroy()方法
  • 建议线程正常停止-->利用次数，不建议死循环
  • 建议使用一个标志位进行终止变量，当flag=true时，则终止线程运行

package com.thread.fivesStates;

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

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("线程正在运行... ...." + i++);
        }
    }

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

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if (i == 900) {
                //调用stop方法，切换标志位让线程停止
                testStop.stop();
                System.out.println("线程该停止了");
            }
        }
    }

}

部分结果：
main897
main898
main899
main900        //线程到900就停止
线程正在运行... ....688
线程正在运行... ....689
线程该停止了
main901
main902
2.7.2.2 线程休眠

package com.thread.fivesStates;

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

//模拟倒计时
public class TestSleep2 {
    public static void main(String[] args) {
//        tenDown();
//    打印当前系统时间
        Date startTime = new Date(System.currentTimeMillis());
        while (true) {
            try {
                Thread.sleep(1000);
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                startTime = new Date(System.currentTimeMillis());//更新当前时间
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    //模拟倒计时
    public static void tenDown() throws InterruptedException {
        int num = 10;
        while (true) {
            Thread.sleep(1000);
            System.out.println(num--);
            if (num <= 0) {
                break;
            }
        }
    }
}
2.7.2.3 线程礼让

礼让不一定成功，看CPU心情

package com.thread.fivesStates;
//测试礼让线程，礼让不一定成功，看CPU心情

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() + "线程停止执行");
    }
}

B线程开始执行
A线程开始执行
B线程停止执行
A线程停止执行
2.7.2.4 Join

2.7.3 线程状态观测

package com.thread.fivesStates;

//观测线程状态
public class TestState {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            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) {//只要线程不终止，就一直输出状态
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}

2.8 线程优先级

package com.thread.fivesStates;

//测试线程优先级
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);
        Thread thread6 = new Thread(myPriority);
//        先设置优先级
        thread1.start();
        thread2.setPriority(1);
        thread2.start();

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

        thread4.setPriority(10);//最大优先级=10
        thread4.start();

        thread5.setPriority(6);
        thread5.start();

        thread6.setPriority(8);
        thread6.start();
    }

}

class MyPriority implements Runnable {

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

2.9 守护线程

package com.thread.fivesStates;

//测试守护线程
public class TestDaemo {
    public static void main(String[] args) {
        God god = new God();
        You you = new You();

        Thread thread = new Thread(god);
        thread.setDaemon(true);//设置为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("你一生都开心的活着" + i);
        }
        System.out.println("-===========goodbye! world!");
    }
}

三、线程同步

3.1 线程同步机制

1. 线程同步

线程同步：多线程操作同一个资源

并发：同一个对象被多个线程同时操作

  • 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象。这个时候就需要线程同步。

  • 线程同步是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下个线程再使用。

  • 线程同步条件：队列+锁

2. 锁机制

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

3. 三个线程不安全的例子（多线程同一时间操作了同一个位置）

//例子1：
//不安全的买票
//买火车票例子：多线程同时操作同一对象
//存在问题：内存控制不当
//线程不安全，有负数出现
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        ByTicket byTicket = new ByTicket();
        new Thread(byTicket, "苦逼的我们").start();
        new Thread(byTicket, "牛逼的我们").start();
        new Thread(byTicket, "可恶的黄牛党").start();
    }
}

class ByTicket implements Runnable {
    //总票数
    private int ticketNums = 10;//ticketNums为共享资源，数据会紊乱
    boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            try {//模拟个延时，避免只运行一个线程，放大问题
                buy();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

    }

    private void buy() throws InterruptedException {
        if (ticketNums <= 0) {
            flag = false;
            return;
        }
        //模拟时延
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNums--);
    }
}




//例子2：
//不安全取钱
//两个人去银行取钱
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100, "结婚基金");
        Drawing you = new Drawing(account, 50, "你");//可能会出现you和girFriend同时操作account
        Drawing girFriend = new Drawing(account, 100, "girFriend");
        you.start();
        girFriend.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;

    }

    //取钱
    @Override
    public void run() {
        //判断卡里有没有钱
        if (account.money - drawingMoney < 0) {
            System.out.println(Thread.currentThread().getName() + "钱不够，取不了");
            return;
        }
        try {
            //sleep可以放大问题的发生性
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        //卡余额=余额-你取的钱
        account.money = account.money - drawingMoney;
        //你手里的钱
        nowMoney = nowMoney + drawingMoney;
        System.out.println(account.name + "余额为：" + account.money);
        // Thread.currentThread().getName()=this.getName()
        System.out.println(this.getName() + "手里的钱" + nowMoney);
    }
}



//例子3：
//线程不安全的集合
public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(() -> {
                list.add(Thread.currentThread().getName());
            }).start();
        }
        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println(list.size());
    }
}

3.2  同步方法与同步块

1. 同步方法:public synchronized void method(int args){}

  • synchronized方法控制对"对象"的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞。方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
  • 缺陷：若将一个大的方法声明为synchronized将会影响效率，方法里面需要修改的内容才需要锁，锁的太多，浪费资源

2. 同步块：synchronized (Obj){}

  • Obj称之为同步监视器

    • Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
    • 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

  • 同步监视器的执行过程

    1. 第一个线程访问，锁定同步监视器，执行其代码
    2. 第二个线程访问，发现同步监视器被锁定，无法执行
    3. 第一个线程访问完毕，解锁同步监视器
    4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问

3. 将上述3个不安全例子，利用同步方法和同步块改为安全方法

//例子1改进
//利用synchronized 同步方法，锁的是this，即对象本身
private synchronized void buy() throws InterruptedException {
    if(ticketNums<=0){
        flag=false;
        return;
    }
    Thread.sleep(100);
    System.out.println(Thread.currentThread().getName()+"->拿到了第"+ticketNums--+"张票");
}

//运行结果
小明->拿到了第10张票
黄牛党->拿到了第9张票
黄牛党->拿到了第8张票
黄牛党->拿到了第7张票
黄牛党->拿到了第6张票
黄牛党->拿到了第5张票
黄牛党->拿到了第4张票
黄牛党->拿到了第3张票
小王->拿到了第2张票
小王->拿到了第1张票


//例子2改进
//此处若只使用同步方法锁的是class Drawing，而多线程操作的为account
//因此应当使用同步块synchronized(account){}锁定account
//锁定的对象应该是变化的量，即需要增、删、改的对象
@Override
public void run() {
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    synchronized (account){//锁定account
        if(account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了钱");
            return;
        }
        account.money=account.money-drawingMoney;
        nowMoney=nowMoney+drawingMoney;

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

//运行结果
结婚基金余额为：900
girlFriend手里的钱100
结婚基金余额为：850
你手里的钱50
    

//例子3改进
public class UnsafeList {
    public static void main(String[] args) throws InterruptedException {
        List<String> list=new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                synchronized (list){//锁定list
                    list.add(Thread.currentThread().getName());
                }
            }).start(); 
        }
        Thread.sleep(3000);
        System.out.println(list.size());
    }
}

//补充CopyOnWriteArrayList，线程安全的集合
//位于并发编程包java.util.concurrent.CopyOnWriteArrayList

3.3 死锁

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

死锁例子：

package com.thread.syn;

//多个线程互相抱着对方需要的资源，然后形成僵持
public class DeadLock {
    public static void main(String[] args) {
        Makeup g1 = new Makeup(0, "灰姑娘");
        Makeup g2 = new Makeup(1, "白雪公主");

        g1.start();
        g2.start();
    }
}

//口红
class Lipstick {

}

//镜子
class Mirror {

}

class Makeup extends Thread {
    //需要的资源只有一份，static
    static Lipstick lipstick = new Lipstick();
    static Mirror mirror = new Mirror();
    int choice;//选择
    String girlsName;//使用化妆品的女孩

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

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

    //化妆,互相持有对方的锁,需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红的锁
                System.out.println(this.girlsName + "获得口红的锁 ");
                Thread.sleep(1000);
                synchronized (mirror) {//一秒钟后获得镜子的锁
                    System.out.println(this.girlsName + "获得镜子的锁 ");
                }

            }
        } else {
            synchronized (mirror) {//获得镜子的锁
                System.out.println(this.girlsName + "获得镜子的锁 ");
                Thread.sleep(2000);
                synchronized (lipstick) {//一秒钟后获得口红的锁
                    System.out.println(this.girlsName + "获得口红的锁 ");
                }

            }
        }
    }
}

//运行结果

灰姑凉获得口红的锁

白雪公主获得镜子的锁

//互相持有了对方的锁，程序没法继续运行

解决办法：将已获得的资源释放后再去获得下一个

   //化妆,互相持有对方的锁,需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice == 0) {
            synchronized (lipstick) {//获得口红的锁
                System.out.println(this.girlsName + "获得口红的锁 ");
                Thread.sleep(1000);
            }
            synchronized (mirror) {//一秒钟后获得镜子的锁
                System.out.println(this.girlsName + "获得镜子的锁 ");
            }
        } else {
            synchronized (mirror) {//获得镜子的锁
                System.out.println(this.girlsName + "获得镜子的锁 ");
                Thread.sleep(2000);
            }
            synchronized (lipstick) {//一秒钟后获得口红的锁
                System.out.println(this.girlsName + "获得口红的锁 ");
            }
        }
    }
  • 死锁避免方法，需要解决下面四个死锁必要条件中的一个或多个条件
    • 互斥条件：一个资源每次只能被一个进程使用
    • 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
    • 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
    • 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系

3.4 Lock(锁）

抢票例子：

package com.thread.syn;

import java.util.concurrent.locks.ReentrantLock;

//测试Lock
public class TestLock {
    public static void main(String[] args) {
        TestLck2 test = new TestLck2();
        new Thread((test)).start();
        new Thread((test)).start();
        new Thread((test)).start();
    }
}

class TestLck2 implements Runnable {
    int ticketNum = 10;
    //定义Lock锁
    private final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
//            加锁
            try {
                lock.lock();
                if (ticketNum > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println(ticketNum--);

                } else {
                    break;
                }
            } finally {
//解锁
                lock.unlock();
            }

        }
    }
}

总结：

四、线程协作通信

4.1 生产者消费者模式

1. 线程通信实际上是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间互相依赖，互为条件。

  • 对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，有需要马上通知消费者消费

  • 对于消费者，在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费
  • 在生产者消费者问题中，仅有synchronized是不够的
    • synchronized可阻止并发更新同一个共享资源，实现同步
    • 但是synchronized不能用来实现不停线程之间的消息传递（通信）

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

3. 解决方式一、

 4. 解决方式二、

        并发协作模式“生产者/消费者模式”---->信号灯法

4.2 管程法

package com.thread.communication;


//测试:生产者消费者模型-->利用缓冲区解决，管程法，线程协作通信
//生产者，消费者，产品，缓冲区
public class TestProducerConsumer {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Customer(container).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));
        }
    }
}

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

    public Customer(SynContainer container) {
        this.container = container;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            container.pop();

        }
    }
}

//产品
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);
            }
        }
//    如果没满，我们就需要丢入产品
        System.out.println("生产了" + chicken.id + "只鸡");
        chickens[count] = chicken;
        count++;

        //通知消费者消费
        this.notifyAll();
    }

    //消费者消费产品
    public synchronized Chicken pop() {
        if (count == 0) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
//等待生产者生成，消费者等待状态

        //否则可以进行消费
        count--;
        Chicken chicken = chickens[count];
        System.out.println("消费了第" + chicken.id + "只鸡");
        this.notifyAll();
        //吃完了，通知生产者生成
        return chicken;
    }


}

4.3 信号灯法

package com.thread.communication;

//信号灯法，标志位解决
public class SignalLamp {
    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++) {
            tv.watch();
        }
    }
}

//产品：节目
class TV {
    //演员表演，观众等待 T
    //观众观看，演员等待 F
    String voice;
    boolean flag = true;

    //演员表演，
    public synchronized void play(String voice) {
        if (!flag) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println("演员表演了" + voice);
//通知观众观看
        this.notify();
        this.voice = voice;
        this.flag = !this.flag;

    }

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


}

五、线程池

5.1 使用线程池

  • 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大

  • 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完后放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具

  • 好处：

    • 提高了响应速度（减少了创建新线程的时间）
    • 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
    • 便于线程管理
      • corePoolSize：核心池的大小
      • maximumPoolSize：最大线程数
      • keepAliveTime：线程没有任务时最多保持多长时间后会终止

  • JDK 5.0起提供了线程池相关的API：ExecutorService和Executors

  • ExecutorService：真正的线程池接口。常见子类ThreadPoolExcutor

    • void execute(Runnable command)：执行任务/命令，没有返回值，一般用来执行Runnable
    • <T>Future<T>submit(Callable<T>task)：执行任务，有返回值，一般用来执行Callable
    • void shutdown()：关闭连接池

  • Executors：工具类、线程类的工厂类，用于创建并返回不同类型的线程池

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

//测试线程池
public class TestPool {
    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        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());
    }
}

zlq825
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#多线程学习笔记
wangyunman的博客
08-23 715
C#多线程 1、多线程使用一般方法 Thread t = new Thread(new ThreadStart(Method)); Method为无参函数，若要传递参数，可以将Method的参数设置为object类型。 2、多线程处理List 最近碰到了多线程处理List的问题，开始的想法是开启5个线程，每个线程轮流获取List中的字符串，但是处理完一个字符串就有一个问题，线程无法重用，线程重用可...
Java 多线程学习笔记（狂神）
qq_36188127的博客
11-18 3170
第1章 1.1 什么是线程 栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，栈和堆的大小都可以通过 JVM 的启动参数来进行调整，栈空间用光了会引发 StackOverflowError，而堆和常量池空间不足则会引发 OutOfMemoryError。 String str = new String("hello"); 上面的语句中变量 str 放在栈上，用 new 创建出来的字符串对象放在堆上，而 “hello” 这个字面量是放在方法区的。 1.2 线程的创建与运行 1.2.1 继承 T
多线程学习笔记05线程协作
asdfghjkl_zth的博客
02-01 2524
文章目录多线程学习笔记05线程协作线程通信解决方式1管程法解决方式2信号灯法 多线程学习笔记05线程协作 线程通信 应用场景：生产者和消费者问题 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费； 如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止； 如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。 我们来分析一下： 首先，这是一个线程同步问题，生产者和消费者共享同一个资
Java多线程学习笔记
Mike_ToUp
06-15 646
进程和线程的概念 进程：程序（任务）的执行过程。持有资源（共享内存，共享文件）和线程 线程：系统中最小的执行单元。同一进程中有多个线程。 线程共享进程的资源。 线程的交互：互斥/同步Java语言对线程的支持示意图： Thread常用方法：线程的创建：Thread（String name） / Thread（Runnable target）线程的方法： 启动线程：void start（） 线程休眠
JAVA 多线程学习笔记
03-27
NULL 博文链接：https://baobeituping.iteye.com/blog/1190260
多线程学习笔记.docx
06-16
包括线程和进程的关系，线程的三种创建方式，继承thread，实现runnable接口，实现callable接口，线程同步，生产者消费者模式
多线程 学习笔记.md
05-04
多线程 学习笔记.md
java多线程学习笔记
03-01
这篇文档和对应的源代码 博文链接：https://interper56-sohu-com.iteye.com/blog/172303
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 970
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 925
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 892
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
Java解决最长公共前缀
无人罪的博客
04-28 243
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
MSE实现全链路灰度实践
云计算、数据库、大数据、深度学习、NLP、Python
04-24 470
待更新。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 911
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
Spring cloud原理详解
qq_33449977的博客
04-28 354
想象一下，你开了一家餐馆，一开始只卖汉堡，后来生意火了，你又增加了炸鸡、披萨、冰淇淋各种摊位，每个摊位就是一个微服务，它们各自独立工作，但又得相互配合。有时候，某个服务可能太忙了，电话老打不通，这时候Spring Cloud还有个叫Hystrix的断路器，它会说：“嘿，别打了，那边线路忙，我给你个备用方案或者告诉你稍后再试。至于餐馆运营情况，Spring Cloud Sleuth和Zipkin这些工具，就像监控摄像头，记录服务间的每一次交互，方便你查看哪里出了问题，优化服务流程。
【限流】基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
最新发布
qq_43209531的博客
04-30 255
基于springboot（拦截器） + redis（执行lua脚本）实现注解限流
公考学习平台|基于SprinBoot+vue的公考学习平台(源码+数据库+文档)
weixin_66413741的博客
04-30 842
本共享汽车管理系统有管理员和用户。管理员功能有个人中心，用户管理，投放地区管理，汽车信息管理，汽车投放管理，汽车入库管理，使用订单管理，汽车归还管理。用户可以在注册登录，可以对汽车进行使用产生订单，还可以归还。因而具有一定的实用性。本站是一个B/S模式系统，采用Spring Boot框架，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得共享汽车管理系统管理工作系统化、规范化。
Java多线程编程学习笔记之十二：生产者—消费者模型（含代码）
06-02
好的，下面是Java多线程编程学习笔记之十二：生产者—消费者模型的相关内容和代码。 ## 生产者—消费者模型简介 生产者—消费者模型是一种常见的多线程并发模型，它涉及到两个角色：生产者和消费者。生产者负责...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值