Day 007_多线程

最新推荐文章于 2024-03-14 14:35:12 发布
最新推荐文章于 2024-03-14 14:35:12 发布
阅读量164 收藏
点赞数
分类专栏： 狂神说Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sssurprise/article/details/107469080
版权

多线程

进程 线程

process 进程，执行程序的一次执行过程，动态。系统资源分配的单位

thread 线程，CPU调度和执行的单位。进程中至少有一个线程

多线程是模拟出来的，真正的多线程是有多个CPU，多核。

在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程

main()主线程，系统的入口，用于执行整个程序

线程就是独立的执行路径

在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为干预的

对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制

线程会带来额外的开销，如cpu调度时间，并发控制开销

每个线程在自己的工作内存交互，内存控制不当会造成数据不一致

线程创建

线程不一定立即执行，CPU安排调度

三种创建方式

Thread class：继承Thread类

Runnable接口：实现Runnable接口

Callable接口：实现Callable接口

Thread class
  1. 自定义线程类继承Tread类
  2. 重写run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程
public class TestThread1 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线程，主线程

        //创建一个线程对象
        TestThread1 testThread1 = new TestThread1();
        //调用start()方法开启线程，同时执行；改成run()时先执行run()方法的
        testThread1.start();
        for (int i = 0; i < 200; i++) {
            System.out.println("我在学习多线程---"+i);
        }
    }
}

两条线程同时执行，交替的

run()先走run()方法

实现多线程下载图片

http://commons.apache.org/proper/commons-io/download_io.cgi

下载Commons-io。解压后复制commons-io-2.7.jar到IDEA中的lib包下，右键lib–>Add to Library

package com.thread;

import org.apache.commons.io.FileUtils;

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

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

    public TestThread2(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) {
        TestThread2 t1 = new TestThread2("https://img.alicdn.com/tfs/TB1DmV8dvzO3e4jSZFxXXaP_FXa-740-420.jpg_760x760Q50s50.jpg_.webp","1.jpg");

        t1.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方法出现问题");
        }
    }
}

Runnable接口

  1. 定义MyRunnable类实现Runnable接口
  2. 实现run()方法，编写线程执行体
  3. 创建线程对象，调用start()方法启动线程

推荐使用Runnable对象，因为Java单继承的局限性

​ Runnable避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

实现接口Runnable具有多线程能力

启动线程：传入目标对象+Thread对象.start()

//买火车票
//多个线程操作同一个资源的情况下，线程不安全，数据紊乱
public class TestThread4 implements Runnable{
    private int ticketNums = 10;
    @Override
    public void run() {
        while (true){
            if (ticketNums <= 0){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--->拿到了第"+ticketNums--+"票");

        }
    }

    public static void main(String[] args) {
        TestThread4 ticket = new TestThread4();

        new Thread(ticket,"xm").start();
        new Thread(ticket,"ls").start();
        new Thread(ticket,"hnd").start();
    }
}

结果会出现不同的人拿到相同的票//多个线程操作同一个资源的情况下，线程不安全，数据紊乱

龟兔赛跑
public class Race 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) {
                    e.printStackTrace();
                }
            }

            //判断比赛是否结束
            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) {
        Race race = new Race();

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

实现Callable接口

  1. 实现Callable接口，需要返回值类型
  2. 重写call方法，需要抛出异常
  3. 创建目标对象
  4. 创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);//1个线程
  5. 提交执行：Future result1 = ser.submit(t1);
  6. 获取结果：boolean r1 = result1.get();
  7. 关闭服务：ser.shutdownNow();
package com.thread.demo02;

import com.thread.TestThread2;
import org.apache.commons.io.FileUtils;

import javax.sql.rowset.CachedRowSet;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

public class TestCallable implements Callable<Boolean> {
    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestCallable (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{
        TestCallable t1 = new TestCallable ("https://img.alicdn.com/tfs/TB1DmV8dvzO3e4jSZFxXXaP_FXa-740-420.jpg_760x760Q50s50.jpg_.webp","1.jpg");
        TestCallable t2 = new TestCallable ("https://pics3.baidu.com/feed/94cad1c8a786c91745aa9e6242098dc93ac757ff.jpeg?token=2734e3e28d06f79c3165c2b02bc0d35a","2.jpg");

        ExecutorService ser = Executors.newFixedThreadPool(2);
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);

        boolean rs1 = r1.get();
        boolean rs2 = r2.get();

        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方法出现问题");
        }
    }
}

好处：可以定义返回值；可以抛出异常

静态代理

eg：结婚 婚庆公司代理

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
        
    }
}

interface Marry{
    void HappyMarry();
}

class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("hxh");
    }
}
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("after");
    }

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

总结：

  1. 真实对象和代理对象都要实现同一个接口
  2. 代理对象要代理真实角色

好处：

  1. 代理对象可以做很多真实对象做不了的事情
  2. 真实对象专注做自己的事情

Lambda表达式

new Thread (()->System.out.println("–")).start();

函数式接口：任何接口，只包含唯一一个抽象abstract方法，那么它就是一个函数式接口。

通过lambda接口创建接口对象

public class TestLambda {

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

//1.定义一个函数式接口
interface ILike{
    void lambda();
}
//2.实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I Like 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 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.用lambda简化
        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.");
    }
}

  1. 定义一个接口 interface

  2. 实现类

  3. 实现类的接口 new一个接口

  4. 把外部的类放在静态内部类（静态内部类放在main函数中 ，加static）

  5. 局部内部类（放在方法中）

  6. 匿名内部类（没有名字）

  7. lambda

    public class TestLambda2 {

     public static void main(String[] args) {
		ILove love =null;
        ILove love = (int a)-> {
                System.out.println("I love you -->"+a);
            };

        love.love(520);
    }
}

interface ILove{
    void love(int a );
}

class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("I love you -->"+a);
    }
}

简化1：去掉参数类型

ILove love =(a)-> {
  System.out.println("I love you -->"+a);
};

简化2：简化括号

love= a -> {
    System.out.println("I love you -->"+a);
};

简化3：去掉花括号（单行内容可以去掉花括号）

love= a -> System.out.println("I love you -->"+a);

总结：

  1. lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
  2. 前提是接口为函数式接口（只有一个方法）
  3. 多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号

线程状态

创建状态：Thread t = new Thread()

就绪状态：start()

运行状态：CPU调度

阻塞状态：sleep、wait、同步锁定---->就绪状态

死亡状态：中断或结束。一旦进入死亡状态，就不能再次启动

线程方法

SetPriority(int newPriority)：更改线程的优先级

static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程体休眠

void join()：等待该线程终止

static void yield()：暂停当前正在执行的线程对象，并执行其他线程

void interrupt()：中断线程，别用这个方式

boolean isAlive()：测试线程是否处于活动状态

停止方法

不推荐使用JDK提供的stop()、destroy()方法【已废弃】

推荐线程自己停止下来（利用次数，不建议死循环）

建议使用一个标志位进行终止变量。当flag=false，则终止线程运行

public class TestStop 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) {
        TestStop testStop = new TestStop();

        new Thread(testStop).start();

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

线程休眠

sleep(时间)指定当前线程阻塞的毫秒数；1000毫秒=1秒

sleep存在异常InterException；需要抛出

sleep时间达到后线程进入就绪状态

sleep可以模拟网络延时，倒计时等

每个对象都有一个锁，sleep不会释放锁

模拟网络延时：放大问题的发生性

模拟倒计时：

public class TestSleep2 {
    public static void main(String[] args) {
        try {
            tenDown();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void tenDown() throws InterruptedException{
        int num = 10;

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

打印当前系统时间：

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

public class TestSleep2 {
    public static void main(String[] args) {
        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) {
                e.printStackTrace();
            }
        }
    }
    public static void tenDown() throws InterruptedException{
        int num = 10;

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

线程礼让

让当前正在执行的线程暂停，但不阻塞

将线程从运行状态转为就绪状态

让cpu重新调度，礼让不一定成功，看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()+"线程停止执行");
    }
}

Join

合并线程，代此线程执行完成后，再执行其他线程，其他线程阻塞

插队：

public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程VIP"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //启动线程
        TestJoin testJoin= new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();

        //主线程
        for (int i = 0; i < 1000; i++) {
            if (i ==200){
                thread.join();//插队
            }
            System.out.println("main"+i);
        }
    }
}

线程状态观测

new：新生

runnable：就绪

blocked：被阻塞、等待监视器锁定

waiting：等待

timed_waiting：等待另一个线程执行动作达到指定等待时间

terminated：已退出的线程处于此状态

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) {
                    e.printStackTrace();
                }
            }
            System.out.println("/");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察启动
        thread.start();
        thread.getState();
        System.out.println(state);//Run

        while (state != Thread.State.TERMINATED) {//只要线程不终止就一直输出
            Thread.sleep(100);
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}

线程优先级

1~10

Thread.MIN_PRIORITY = 1;

Thread.MAX_PRIORITY = 10;

Thread.NORM_PRIORITY = 5;

getPriority() setPriority(int xxx)

测试线程优先级：

public class TestPriority {
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());

        MyProprity myProprity = new MyProprity();

        Thread t1 = new Thread(myProprity);
        Thread t2 = new Thread(myProprity);
        Thread t3 = new Thread(myProprity);
        Thread t4 = new Thread(myProprity);
        Thread t5 = new Thread(myProprity);
        Thread t6 = new Thread(myProprity);

        //先设置优先级再启动
        t1.start();
        t2.setPriority(1);
        t2.start();

        t3.setPriority(4);
        t3.start();

        t4.setPriority(Thread.MAX_PRIORITY);//10
        t4.start();

        t5.setPriority(7);
        t5.start();

        t6.setPriority(9);
        t6.start();


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

    }
}

不一定优先级高的先执行，但大多数是。优先级低只是意味着获得调度的概率低。

守护daemon线程

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

虚拟机必须确保用户线程执行完毕 main()

虚拟机不用等待守护线程执行完毕 gc()

上帝守护你：

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!");
    }
}

线程同步

多线程操作同一个资源

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

线程同步：一种等待机制，进入这个对象的等待池形成队列。

synchronized：形成条件：队列+锁

涉及到并发，用synchronized

不安全的买票：线程不安全，有负数

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"hxh").start();
        new Thread(station,"xm").start();
        new Thread(station,"xh").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void  buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }

        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

不安全的取钱：

//两个人去银行取钱，账户
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

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

    //取钱

    @Override
    public void run() {
        //判断有没有钱
        if (account.money-drawingMoney<0){
            System.out.println(Thread.currentThread().getName()+"钱不够，取不了。");
            return;
        }
        //sleep可以放大问题的发生性
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        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);
    }
}

线程不安全的集合

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<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());
    }
}

同步方法

public synchronized void method(int arges){}

每个对象对应一把锁，每个synchronize方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。

缺陷：影响效率

方法里面需要修改的内容才需要锁，锁的太多，浪费资源

synchronized默认锁的是this，它本身

同步块：synchronized (Obj){}

Obj：同步监视器

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

同步监视器的执行过程：（排队上厕所的例子）

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

锁的对象是变化的量

买票：

public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket station = new BuyTicket();

        new Thread(station,"hxh").start();
        new Thread(station,"xm").start();
        new Thread(station,"xh").start();
    }
}

class BuyTicket implements Runnable{

    private int ticketNums = 10;
    boolean flag = true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    //synchronized同步方法，锁的是this
    private  synchronized void  buy() throws InterruptedException {
        //判断是否有票
        if (ticketNums <= 0){
            flag = false;
            return;
        }

        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}

取钱：

package com.syn;

//两个人去银行取钱，账户
public class UnsafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");

        Drawing you = new Drawing(account,50,"你");
        Drawing girlFriend = new Drawing(account,100,"girlFriend");

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

    //取钱

    @Override
    public void run() {
        synchronized (account) {
            //判断有没有钱
            if (account.money - drawingMoney < 0) {
                System.out.println(Thread.currentThread().getName() + "钱不够，取不了。");
                return;
            }
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            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);
        }
    }
}

线程不安全的集合：

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

public class UnsafeList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        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());
    }
}

测试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());
    }
}

死锁

多个线程都在等待对方释放资源，都停止执行的情形

化妆：

public class DeadLock {
    public static void main(String[] args) {
        Makeup g1= new Makeup(0,"hxh");
        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 girlName;//使用化妆品的人

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

    @Override
    public void run() {
        try {
            makeup();//化妆
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //化妆，互相持有对方的锁就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice==0) {
            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(2000);
                    synchronized (lipstick) {
                        System.out.println(this.girlName+"获得口红");
                    }
            }
        }
    }

}

导致程序卡死

修改：把synchronized放到同步外面

public class DeadLock {
    public static void main(String[] args) {
        Makeup g1= new Makeup(0,"hxh");
        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 girlName;//使用化妆品的人

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

    @Override
    public void run() {
        try {
            makeup();//化妆
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //化妆，互相持有对方的锁就是需要拿到对方的资源
    private void makeup() throws InterruptedException {
        if (choice==0) {
            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(2000);

            }
            synchronized (lipstick) {
                System.out.println(this.girlName+"获得口红");
            }
        }
    }

}

产生死锁的四个必要条件

  1. 互斥条件：一个资源每次只能被一个进程使用。
  2. 请求与保持条件：一个进程因素请求资源而阻塞时，对已获得的资源保持不放
  3. 不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
  4. 循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系
    • 上述四个条件，只要破解其中任意一个或多个就可以避免死锁发生

锁Lock

显示定义同步锁。同步锁使用Lock对象充当

java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。

ReentrantLock类：可重入锁，实现了Lock，

import java.util.concurrent.locks.ReentrantLock;

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

语法：

class A{
    private final ReentrantLock lock = new ReentrantLock();
    public void m(){
        lock.lock();
        try{
            //保证线程安全的代码
        }finally{
            lock.unlock();
            //如果同步代码有异常，要将unlock()写入finally语句块
        }
    }
}

synchronized 与 Lock 的对比：

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

线程协作

解决线程之间的通信问题：

  1. wait()：表现线程一直等待，直到其他线程通知，与sleep不同，会释放锁（sleep抱着锁睡觉）
  2. wait(long timeout)：指定等待的毫秒数
  3. notify()：唤醒一个处于等待状态的线程（唤醒）
  4. notifyAll()：唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度
    • 均是Object类的方法，都只能在同步方法或者同步代码中使用，否则会抛出异常

解决方法：

  1. 管程法（利利用缓冲区解决生产者消费者模型）
public class TestPC {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Product(container).start();
        new Customer(container).start();
    }
}

//生产者
class Product extends Thread{
    SynContainer container;
    public Product (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 Customer extends Thread{
    SynContainer container;
    public Customer (SynContainer container){
        this.container=container;
    }

    //消费
    @Override
    public void run() {
        System.out.println("消费了"+container.pop().id+"只鸡");
    }
}

//产品
class Chicken extends Thread{
    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;
    }
}
  1. 信号灯法（通过标志位解决生产者消费者问题）
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("ABC");
            }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 != true){
            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;
    }
}

线程池

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

好处：

  1. 提高响应速度
  2. 降低资源消耗
  3. 便于线程管理
    • corePoolSize：核心池的大小
    • maximumPoolSize：最大线程数
    • keepAliveTime：线程没有任务时最多保持多长时间后会终止

线程池相关API：ExecutorService和Executors

  1. ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

    • void execute(Runable command)：执行任务/命令，没有返回值，一般用来执行Runnable
    • Futuresubmit(Callabletask)：执行任务，有返回值，一般用来执行Callable
    • void shutdown()：关闭连接池

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

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

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

        //执行
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());
        service.execute(new MyThread());

        //2.关闭链接
        service.shutdown();
    }
}

class MyThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName());
        }
    }
}

总结：

  1. 线程的创建（三种）
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadNew {
    public static void main(String[] args) {
        new MyThread1().start();

        new Thread(new MyThread2()).start();

        FutureTask<Integer> futureTask = new FutureTask<Integer>(new MyThread3());
        new Thread(futureTask).start();

        try {
            Integer integer = futureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

//1.继承Thread类
class MyThread1 extends Thread{
    @Override
    public void run() {
        System.out.println("MyThread1");
    }
}


//2.实现Runnable接口
class MyThread2 implements Runnable{
    @Override
    public void run() {
        System.out.println("MyThread2");
    }
}

//3.实现Callable接口
class MyThread3 implements Callable{

    @Override
    public Integer call() throws Exception {
        System.out.println("MyThread3");
        return 100;
    }
}
  1. 线程的同步
怎么会这么难
关注
专栏目录
java多线程并发上传实例_多线程 网络编程 文件上传案例多线程
weixin_33509203的博客
02-26 1265
Day13 多线程3).多线程的好处：提高程序的运行效率，提高用户的体验度。 线程不会因为等待某个资源而进入等待状态创建新的线程:* 定义类继承Thread* 重写方法run* 创建Thread子类的对象* 调用子类对象的方法start()** 为什么继承Thread* Thread类是线程对象类* 继承了Thread,子类也是线程对象** 为什么重写run...
线程导入大数据入库_多线程批量插入数据小结
weixin_39608394的博客
01-14 1197
在测试的过程中，无法避免的需要做一些性能压测，造数据的时长在此时就会备受关注。比如，造数据的时候用多线程还是多进程，用直接插入DB方式还是用先写文件后导入mysql的方式，写文件是写批量sql后面source导入，还是写文本格式后面load ito file导入，使用不同的方法耗时结果肯定是不一样的。除此之外，还有mysql的版本，DB的引擎，表的结构设计这些都会影响大量数据插入的时间。这次导入数...
多线程_Day01
Anoraker的小屋
02-03 7122
多线程 程序 进程 线程 程序是为了完成特定的任务，用某种语言编写的一组指令的集合，通常指一段静态的代码 进程是程序的一次成型过程或者是正在运行的程序，是一个动态的过程，有它自身的产生，存在和消亡的过程，称为生命周期 线程是进程的细化，是一个进程内部的一个执行路径， 多线程的优点 提高应用程序的响应 提高计算机系统CPU的利用率 改善程序结构，将即长有复杂的进程分为多个线程，独立运行，有利于理解和修改 线程的创建和使用 第一种创建方式 创建一个继承Thread类的子类 重写父类Thread类ru
多线程_Day02
Anoraker的小屋
02-04 7082
多线程 线程的生命周期 新建 ： (初始状态)调用Thread子类对象的start()方法 就绪 : 获取CPU执行权进入就绪状态， 如果失去执行权或调用yield()方法就会到新建状态 运行 : 在获取就绪状态时开始运行run()方法, 或线程调用stop()以及出现异常没处理线程结束 死亡 : (最终状态)程序结束运行 阻塞 : (不是最终状态)线程在执行时调用sleep(long millis)和join()方法以及等待同步锁,wait(),suspend() 线程的同步 多个线程执行的
多线程day1-1
weixin_43695211的博客
05-28 1492
多线程 创建多线程方式： Thread public class ThreadTest01 extends Thread{ private String url; private String name; public ThreadTest01(String url,String name){ this.url=url; this.name=name; } //多线程执行体 @Override ..
Python学习DAY10_进程和线程
学习小屋
03-04 1108
进程就是操作系统中执行的一个程序，操作系统以进程为单位分配存储空间，每个进程都有自己的地址空间、数据栈以及其他用于跟踪进程执行的辅助数据，操作系统管理所有进程的执行，为它们合理的分配资源。进程可以通过 fork 或 spawn 的方式来创建新的进程来执行其他的任务，不过新的进程也有自己独立的内存空间，因此必须通过进程间通信机制（IPC，Inter-Process Communication）来实现数据共享，具体的方式包括管道、信号、套接字、共享内存区等。
day6-day7多线程和并发
m0_46391590的博客
05-31 806
线程与进程的区别线程是操作系统能够进行运算调度最小的单元，是进程的执行单元。线程是进程内部创建和调度的，共享进程的资源；进程具有独立的地址空间，而线程共享进程的地址空间。进程之间通信需要特殊的机制，如管道、消息队列，而线程之间通信可以通过共享内存直接访问。进程切换开销较大，涉及到地址空间的切换，而线程切换开销较小，因为线程共享地址空间和其他资源。
Java多线程编程
chenmi123321的博客
10-19 1095
java
【多线程】OOM问题
studyday1的博客
03-14 559
编码踩坑——多线程可能带来意想不到的OOM_多线程oom-CSDN博客
C# 多线程详细讲解
热门推荐
fenglearning的博客
05-27 2万+
C#多线程 一、基本概念 1、进程 首先打开任务管理器，查看当前运行的进程： 从任务管理器里面可以看到当前所有正在运行的进程。那么究竟什么是进程呢？ 进程（Process）是Windows系统中的一个基本概念，它包含着一个运行程序所需要的资源。一个正在运行的应用程序在操作系统中被视为一个进程，进程可以包括一个或多个线程。 线程是操作系统分配处理器时间的基本单元，在进程中可以有多个线程同时执行代码。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式）， 一个进程运
day15_多线程02.zip
09-12
"day15_多线程02"这个标题暗示我们将会深入探讨多线程的第二部分，这可能是一个课程或者教程的第十五天内容，重点在于多线程的进阶主题。尽管没有具体的标签，我们可以假设这个压缩包可能包含了源代码、笔记、示例或...
day14_多线程01.zip
09-12
本资源“day14_多线程01.zip”可能是某个教学课程或者学习资料的一部分，着重讲解了多线程的基础知识和应用。虽然没有具体的标签提供额外信息，但我们可以根据标题和描述来深入探讨多线程这一主题。 多线程是指在一...
python 08、多任务编程多线程 6-1_多线程并发、HTTPServer 2.0_Day06_AM.mp4
03-09
python 08、多任务编程多线程 6-1_多线程并发、HTTPServer 2.0_Day06_AM.mp4
python 20、爬虫 06-1_多线程爬虫、BeautifulSoup模块_Day06_am.mp4
03-09
python 20、爬虫 06-1_多线程爬虫、BeautifulSoup模块_Day06_am.mp4
day17_线程创建、线程同步、线程状态.pdf
11-02
Java多线程编程基础知识点 本节课主要讲解了Java多线程编程的基础知识，包括线程的概念、线程与进程的区别、多线程的随机性、Java程序的进程中的线程、线程的创建方式、线程的执行流程、线程内存图等。 1. 进程与...
vmware workstatiions pro 17.6.1个人使用免费，不用证书直接安装使用
11-18
虚拟机vmware workstatiions pro 17.6.1个人使用免费，不用证书直接安装使用
scipy-1.2.0-cp35-cp35m-linux_armv7l.whl
11-18
scipy-1.2.0-cp35-cp35m-linux_armv7l.whl
基于springboot爬虫高考志愿智能推荐系统源码数据库文档.zip
最新发布
11-18
基于springboot爬虫高考志愿智能推荐系统源码数据库文档.zip
bimdata_api_client-4.3.0-py3-none-any.whl
11-18
bimdata_api_client-4.3.0-py3-none-any.whl
秒杀系统设计与实现：多线程技术剖析
在本篇文档"多线程-day03"中，主要讨论了关于多线程编程在秒杀系统中的应用与实现。秒杀是一种常见的电子商务促销活动，涉及到快速销售有限数量的商品，通常设置库存和时间限制，对系统并发处理能力有较高要求。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值