多线程编程学习笔记

最新推荐文章于 2024-07-27 16:42:06 发布
最新推荐文章于 2024-07-27 16:42:06 发布
阅读量825 收藏
点赞数
分类专栏： 学习笔记 文章标签： java 多线程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42098332/article/details/108626759
版权

目录

概述

笔记参照b站up主：遇见狂神说的视频，链接https://www.bilibili.com/video/BV1V4411p7EF

狂神：只要学不死，就往死里学

1、多线程实现方式

  • 继承Thread类
  • 实现runable接口
  • 实现callable接口

2、继承Thread

1、使用

package com.xwy;

/**
 * @author levi
 * @create 2020/9/13 5:11 下午
 */
//创建线程方法1 集成Thread
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();
//        调用start方法开启线程
        testThread01.start();
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学多线程。。。。"+i);
        }
    }
}

2、网图下载

package com.xwy;

import org.apache.commons.io.FileUtils;

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

/**
 * @author levi
 * @create 2020/9/13 5:31 下午
 */
public class TestThread02 extends Thread{
    private String url;
    private String name;
    public TestThread02(String url,String name){
        this.name = name;
        this.url = url;
    }
    @Override
    public void run() {
        WebDownloader webDownloader = new WebDownloader();
        webDownloader.downloader(url,name);
        System.out.println("下载了文件名为"+name+"的文件");
    }
    public static void main(String[] args) {
        TestThread02 t1= new TestThread02("http://127.0.0.1:8000/file/1.jpg","1.jpg");
        TestThread02 t2= new TestThread02("http://127.0.0.1:8000/file/1.jpg","2.jpg");
        TestThread02 t3= new TestThread02("http://127.0.0.1:8000/file/1.jpg","3.jpg");
        t1.start();
        t2.start();
        t3.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方法出现错误");
        }
    }
}

3、实现Runable接口

创建线程方式二：实现runable接口，重写run方法，执行线程需要丢入runable接口实现类，调用start方法

package com.xwy;

/**
 * @author levi
 * @create 2020/9/13 6:06 下午
 */
//创建线程方式二：实现runable接口，重写run方法，执行线程需要丢入runable接口实现类，调用start方法
public class TestThread03 implements Runnable{
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 20; i++) {
            System.out.println("我在看代码。。。。"+i);
        }
    }
    public static void main(String[] args) {
//      创建runable接口的实现对象
        TestThread03 testThread03 = new TestThread03();
//      创建线程对象
        Thread thread = new Thread(testThread03);
//      调用start方法开启线程
        thread.start();

//      new Thread(testThread03).start();
        
        for (int i = 0; i < 2000; i++) {
            System.out.println("我在学多线程。。。。"+i);
        }
    }
}

建议使用实现Runable接口的方式，因为java的单继承局限性

4、并发问题

package com.xwy;

/**
 * @author levi
 * @create 2020/9/13 6:14 下午
 */
public class TestThread04 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) {
        TestThread04 ticket = new TestThread04();
        new Thread(ticket,"小明").start();
        new Thread(ticket,"老师").start();
        new Thread(ticket,"黄牛").start();
    }
}

小明拿到了第8张票
黄牛拿到了第10张票
老师拿到了第9张票
小明拿到了第7张票
老师拿到了第6张票
黄牛拿到了第7张票
老师拿到了第5张票
小明拿到了第5张票
黄牛拿到了第5张票
老师拿到了第4张票
黄牛拿到了第3张票
小明拿到了第4张票
黄牛拿到了第2张票
老师拿到了第2张票
小明拿到了第1张票

出现问题：同一张票被多人拿到

6、龟兔赛跑

package com.xwy;

/**
 * @author levi
 * @create 2020/9/13 6:22 下午
 */
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(100);
                } 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();
    }
}

这里我设置成10ms兔子也参与不进来。。。，可能电脑运行太快了吧 假装不开心～

7、实现Callable接口

用callable重新实现图片下载

package com.xwy02;

import com.xwy.TestThread02;
import org.apache.commons.io.FileUtils;

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

/**
 * @author levi
 * @create 2020/9/13 8:54 下午
 */

public class TestCallable implements Callable<Boolean> {
    private String url;
    private String name;
    public TestCallable(String url,String name){
        this.name = name;
        this.url = url;
    }
    @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("http://127.0.0.1:8000/file/1.jpg","1.jpg");
        TestCallable t2= new TestCallable("http://127.0.0.1:8000/file/1.jpg","2.jpg");
        TestCallable t3= new TestCallable("http://127.0.0.1:8000/file/1.jpg","3.jpg");
//        1创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
//        2提交执行
        Future<Boolean> r1 = ser.submit(t1);
        Future<Boolean> r2 = ser.submit(t2);
        Future<Boolean> r3 = ser.submit(t3);
//        3获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
//        4关闭服务
        ser.shutdown();
    }
}
//下载器
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方法出现错误");
        }
    }
}

callable的好处：

  • callable可以定义返回值
  • 可以抛出异常

8、静态代理

结婚：

  • 你：真实角色
  • 婚庆公司： 代理你，帮你处理结婚的事情
  • 结婚：实现都实现结婚接口

静态代理模式：

  • 真是对象和代理对象都要实现同一个接口
  • 代理对象要代理真实角色

好处：

  • 代理对象可以做好多真实对象做不了的事情
  • 真实对象专注做自己的事情
package com.proxystate;

/**
 * @author levi
 * @create 2020/9/13 9:04 下午
 */

public class StateProxy{
    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("xxx和xwy结婚了");
    }
}
//代理角色 帮助你结婚
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  before(){
        System.out.println("结婚前布置现场");
    }
    private  void  after(){
        System.out.println("结婚之后收尾款");
    }
}

代理模式在多线程内使用：

package com.proxystate;

/**
 * @author levi
 * @create 2020/9/13 9:04 下午
 */

public class StateProxy{
    public static void main(String[] args) {
        You you = new You();
        new Thread( ()-> System.out.println("我爱你") ).start();
        new WeddingCompany(you).HappyMarry();
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.HappyMarry();
    }
}
interface Marry{
    void HappyMarry();
}
//真实角色：我要结婚
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("xxx和xwy结婚了");
    }
}
//代理角色 帮助你结婚
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  before(){
        System.out.println("结婚前布置现场");
    }
    private  void  after(){
        System.out.println("结婚之后收尾款");
    }
}

9、Lambda

1、推导lamadba表达式

package com.lamdba;

/**
 * @author levi
 * @create 2020/9/13 9:39 下午
 */
public class TestLamdba {
//    3静态内部类
    static class Like2 implements ILike {
        @Override
        public void lamdba() {
            System.out.println("I love Lamdba2");
        }
    }

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

        like = new Like2();
        like.lamdba();

//        4 局部内部类
        class Like3 implements ILike {
            @Override
            public void lamdba() {
                System.out.println("I love Lamdba3");
            }
        }
        like = new Like3();
        like.lamdba();

//        5匿名内部类,没有类的名字，必须借助接口或父类
        like = new ILike() {
            @Override
            public void lamdba() {
                System.out.println("I love Lamdba4");
            }
        };
        like.lamdba();
//        6 lamdba简化
        like = ()->{
            System.out.println("I love Lamdba5");
        };
        like.lamdba();
    }
}
//1定义一个接口
interface ILike{
    void lamdba();
}
//2定义一个实现类
class Like implements ILike{
    @Override
    public void lamdba() {
        System.out.println("I love Lamdba");
    }
}

2、带参简化

package com.lamdba;

/**
 * @author levi
 * @create 2020/9/13 9:49 下午
 */
public class TestLamdba2 {
    public static void main(String[] args) {

        ILove love = (int a) ->{
            System.out.println("i love you--->" + a);
        };
//        1干掉参数类型
        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);
        
        love.Love(2);
    }
}
interface ILove{
    void Love(int a);
}

总结：

  • 表达式只有一行代码的情况下，才能去掉{}，不然必须用代码块包裹
  • 接口必须是函数式接口
  • 多个参数也可以去掉参数类型，要去掉都去掉，必须加括号

10、线程状态

1、线程停止

  • 不推荐使用stop，destory，一般使用标志位停止
  • 建议线程正常停止，利用次数，不建议死循环
package com.state;

/**
 * @author levi
 * @create 2020/9/13 10:01 下午
 */
public class TestStop implements Runnable {
    private boolean flag  = true;
    @Override
    public void run() {
        int i = 0;
        while (flag){
            System.out.println("run .......thread..--->"+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("线程该停止了");
            }
        }
    }
}

2、线程休眠

Sleep

  • 每个对象都有一个锁，sleep不会释放锁
  • sleep存在异常抛出InterruptedException()
  • sleep时间达到后进入就绪状态
模拟网络延时
  • 放大问题发生性
  • 模拟倒计时
package com.state;

/**
 * @author levi
 * @create 2020/9/13 10:10 下午
 */
public class TestSleep2 {
    public static void main(String[] args) {
        try {
            tenDown();
        } 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;
            }
        }
    }
}
  • 打印当前系统时间
package com.state;

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

/**
 * @author levi
 * @create 2020/9/13 10:10 下午
 */
public class TestSleep2 {
    public static void main(String[] args) {
//        try {
//            tenDown();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        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;
            }
        }
    }
}

3、线程礼让

  • 让当前线程暂停，但是不阻塞
  • 运行转为就绪
  • cpu重新调度，礼让不一定成功，看cpu心情
package com.state;

/**
 * @author levi
 * @create 2020/9/13 10:20 下午
 */
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()+"结束执行");
    }
}

4、线程强制执行

  • Join合并线程，待此线程执行完成后，再执行其他线程，其他线程堵塞
  • 可以想象成插队
package com.state;

/**
 * @author levi
 * @create 2020/9/13 10:25 下午
 */
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 < 500; i++) {
            if(i == 200){
                thread.join(); //插队
            }
            System.out.println("main" + i);
        }
    }
}

结果，主线程200前，并发执行，200之后，剩下的没执行的线程先执行完，主线程才继续

5、线程状态观测

package com.state;

/**
* @author levi
* @create 2020/9/14 9:44 上午
*/
//观察测试线程的状态
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); //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); //输出状态
       }
   }
}

6、线程优先级

package com.state;

/**
 * @author levi
 * @create 2020/9/14 9:56 上午
 */
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);

//        设置优先级，在启动
        t1.start();

        t2.setPriority(1);
        t2.start();

        t3.setPriority(2);
        t3.start();

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

        t5.setPriority(3);
        t5.start();

        t6.setPriority(4);
        t6.start();
    }

}
class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"--->"+Thread.currentThread().getPriority());
    }
}
  • 优先级设定在start之前
  • 优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用，都是看cpu的调度

7、守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不等待守护进程执行完毕
  • 如：后台记录操作日志，监控内存，垃圾回收等待
package com.state;

/**
 * @author levi
 * @create 2020/9/14 10:16 上午
 */
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("====good bye world=====");
    }
}

11、线程同步

1、三大不安全案例

买票问题：

  • 好几个人抢到同一张票，或者可能出现-1

银行取钱问题：

  • 出现负数
package com.syn;

/**
 * @author levi
 * @create 2020/9/14 10:53 上午
 */
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(100,"结婚基金");
        Drawing xwy = new Drawing(account,50,"xwy");
        Drawing xxx = new Drawing(account,100,"xxx");
        xwy.start();
        xxx.start();
    }
}
//账户
class Account{
    int money; //余额
    String name; //卡名
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//y银行
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 {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//        卡内余额 = 余额- 取的钱
        account.money = account.money - drawingMoney;
//        手里的钱
        nowMoney = nowMoney + drawingMoney;

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

不安全的集合

package com.syn;

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

/**
 * @author levi
 * @create 2020/9/14 11:10 上午
 */
//线程不安全的集合
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());
    }

}

2、同步方法和同步块

synchronized关键字

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

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

解决三个不安全案例

  • 银行取钱
package com.syn;

/**
 * @author levi
 * @create 2020/9/14 10:53 上午
 */
public class UnSafeBank {
    public static void main(String[] args) {
        Account account = new Account(1000,"结婚基金");
        Drawing xwy = new Drawing(account,50,"xwy");
        Drawing xxx = new Drawing(account,100,"xxx");
        xwy.start();
        xxx.start();
    }
}
//账户
class Account{
    int money; //余额
    String name; //卡名
    public Account(int money, String name) {
        this.money = money;
        this.name = name;
    }
}
//y银行
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(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
//        卡内余额 = 余额- 取的钱
            account.money = account.money - drawingMoney;
//        手里的钱
            nowMoney = nowMoney + drawingMoney;

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

    }
}
  • 买票
package com.syn;

import sun.security.krb5.internal.Ticket;

/**
 * @author levi
 * @create 2020/9/14 10:43 上午
 */
//不安全的买票
public class UnsafeBuyTicket {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"苦逼的我").start();
        new Thread(buyTicket,"牛逼的你").start();
        new Thread(buyTicket,"可恶的黄牛").start();
    }
}
class BuyTicket implements Runnable{
//    票
    private int ticketNums = 10;
    private boolean flag = true;
    @Override
    public void run() {
//        买票
        while (flag){
            try {
                buy();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    private synchronized void buy() throws InterruptedException {
//        判断是否有票
        if(ticketNums <=0){
            flag = false;
            return;
        }
//        模拟面试
        Thread.sleep(100);
//        买票
        System.out.println(Thread.currentThread().getName() + "拿到了" + ticketNums--);
    }
}
  • list
package com.syn;

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

/**
 * @author levi
 * @create 2020/9/14 11:10 上午
 */
//线程不安全的集合
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());
    }

}

3、JUC

package com.syn;

import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @author levi
 * @create 2020/9/16 2:55 下午
 */
//测试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());
    }
}

12、死锁

  • 某个同步块同时拥有“两个对象以上的锁”时就会出现死锁的问题
package com.lock;

/**
 * @author levi
 * @create 2020/9/16 3:01 下午
 */
//多个线程互相抱着对方需要的资源，形成僵持
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 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 + "获得口红的锁");
                }
            }
        }
    }
}

13、Lock

package com.lock;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author levi
 * @create 2020/9/16 3:21 下午
 */

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

        }
    }
}

synchronized和lock的对比：

  • lock是显式锁（手动开启关闭），synchronized是隐式锁，出了作用域自动释放
  • lock只有代码块锁，synchronized有代码块锁和方法锁
  • 使用lock锁，jvm花费较少时间来调度线程，性能更好，具备更好的扩展性
  • 优先使用顺序：lock - 同步代码块 - 同步方法

14、线程协作

1、生产者消费者

管程法

package com.gaoji;

/**
 * @author levi
 * @create 2020/9/16 4:51 下午
 */
//测试生产者消费者，利用缓冲区解决：管程法
public class TestPc {
    public static void main(String[] args) {
        SynContainer container = new SynContainer();
        new Productor(container).start();
        new Consumer(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));
            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{
    //容器计数器
    int count = 0;
    //需要一个容器大小
    Chicken[] chickens = new  Chicken[10];
    //生产者放入产品
    public synchronized void push(Chicken chicken){
        //如果容器满了，就需要等待消费者消费
        if(count==chickens.length){
            //t通知消费者消费，生产等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有满，我们就需要丢入产品
        chickens[count] = chicken;
        count++;
        //通知消费者可以消费了
        this.notifyAll();
    }
    //消费者消费产品
    public synchronized Chicken pop(){
        if(count==0){
            //等待生产者生产，消费者等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果可以消费
        count--;
        Chicken chicken = chickens[count];
        //通知生产者生产
        this.notifyAll();
        return chicken;
    }
}

信号灯法

package com.gaoji;

/**
 * @author levi
 * @create 2020/9/16 5:16 下午
 */
//标志位
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++) {
            tv.watch();
        }
    }
}

//产品
class TV{
    String voice; //节目
    //演员表演观众等待 T
    //观众观看，演员等待 F
    boolean flag = true;
    //表演
    public synchronized void play(String voice){
        if(!flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("演员表演了" + voice);
        //通知观众观看
        this.notifyAll();
        this.voice = voice;
        this.flag = !this.flag;
    }
    //观看
    public synchronized void watch(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("观看了" + voice);
        //通知演员表演
        this.notifyAll();
        this.flag = !this.flag;
    }
}

2、线程池

package com.gaoji;

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

/**
 * @author levi
 * @create 2020/9/16 4:43 下午
 */
public class TestPool {
    public static void main(String[] args) {
        //1创建线程池
        ExecutorService service = Executors.newFixedThreadPool(10);//参数为i线程池大小
        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() {
            System.out.println(Thread.currentThread().getName());
    }
}
聪明的大羊
关注
专栏目录
并发编程之线程池的使用及扩展和优化
ignore
01-04 1961
前言多线程的软件设计方法确实可以最大限度的发挥现代多核处理器的计算能力，提高生产系统的吞吐量和性能。但是，如果一个系统同时创建大量线程，线程间频繁的切换上下文导致的系统开销将会拖慢整个系统。严重的甚至导致内存耗尽导致OOM异常。因此，在实际的生产环境中，线程的数量必须得到控制，盲目的创建大量新车对系统是有伤害的。那么，怎么才能最大限度的利用CPU的性能，又能保持系统的稳定性呢？其中有一个方法就是使用
Posix多线程编程学习笔记1~6
03-17
Posix多线程编程学习笔记1~6,包括线程基础，线程属性，信号灯，条件变量，互斥变量，共享内存六部分内容。很有助于linux下多线程的开发。文档主要包含介绍相应的pthread接口函数，并举了部分相应的例子。
java多线程实现大批量数据导入源码
09-29
java多线程实现大批量数据切分成指定份数的数据，然后多线程处理入库或者导出，线程的个数和每份数据的数量都可以控制
Java中的线程池调优与性能提升技巧
微赚淘客开发者博客
07-16 502
在Java并发编程中，线程池是一个非常重要的工具，它能够帮助我们管理线程的创建和销毁，提高系统的并发性能。通常，核心线程数设置为CPU核心数的2倍，以确保CPU资源的充分利用。在实际应用中，需要根据具体的业务需求和系统资源，动态调整线程池的参数，结合监控和调试工具，持续优化线程池的性能。线程池是一种多线程处理形式，通过提前创建一组线程来处理任务，从而避免了频繁创建和销毁线程的开销。在这个示例中，我们根据服务器的CPU核心数设置了核心线程数和最大线程数，选择了有界队列。工具类来创建各种类型的线程池。
JAVA线程池优化
liuhao0610的博客
09-09 468
前言： 随着信息技术的进步，各行各业对数据价值的重视程度急剧上升，越来越多的数据被分门别类地积聚下来，对数据库的并发要求越来越高，即同一时间点的数据请求越来越多，对实时性的要求也越来越高。实时性其实是不经过批量排队的高并发实时请求的代名词，同一时间的请求量和请求的处理速度直接决定了并发度： 1.优化的代码 //参数初始化 private static final int CPU_COUNT = R...
Java之线程池优化
jay_888的博客
05-21 233
参考资料及博客： https://www.cnblogs.com/10158wsj/p/8338367.html https://www.cnblogs.com/XHJT/p/3905665.html https://zhidao.baidu.com/question/1116525725491169459.html
多线程学习笔记
03-18
GCD的使用更为简单和面向对象，它的目的是简化多线程编程，使得开发者能够更加方便地实现并发执行。 GCD中执行任务的两个常用函数是dispatch_sync和dispatch_async。dispatch_sync函数用于同步执行任务，它将任务...
线程池优化多线程
weixin_42677025的博客
08-24 305
一、spring中已经实现的线程池： 1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，默认每次调用都会创建一个新的线程。 2. SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方。 3. ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类。 4. SimpleThreadPoolTaskExecu
Java中的线程池优化
最新发布
微赚淘客系统开发者博客
07-27 446
通过合理设置核心线程数、最大线程数、任务队列和拒绝策略，并且持续监控和调整线程池的状态，可以在不同的负载条件下保持线程池的高效运行。核心线程数决定了线程池的基础线程数量，而最大线程数限制了线程池能够创建的线程数量。本文将详细探讨线程池的优化策略，涉及线程池的基本概念、常见问题及其解决方案，并通过具体代码示例来说明优化的实现方式。如果任务间隔时间较短，可以设置较短的空闲时间，以减少线程的创建和销毁开销。通过定期检查线程池的状态，如活跃线程数、任务队列长度等，可以及时调整线程池的配置，以适应变化的负载。
JAVA线程池如何调优
热门推荐
Venus's Blog
08-16 1万+
在JAVA中，线程可以使用定制的代码来管理，应用也可以利用线程池。在使用线程池时，有一个因素非常关键：调节线程池的大小对获得最好的性能至关重要。线程池的性能会随线程池大小这一基本选择而有所不同，在某些条件下，线程池过大对性能也有很多不利的影响。 所有线程池的工作方式本质是一样的：有一个任务队列，一定数量的线程会从该任务队列获取任务然后执行。任务的结果可以发回客户端，或保存到数据库，或保存到某个内部数据结构中，等等。但是在执行完任务后，这个线程会返回任务队列，检索另一个任务并执行。 线程池有最小线程数和最大线
Java多线程之线程池调优
yjc0403的博客
11-21 568
Java多线程之线程池调优   默认配置   corePoolSize=1 queueCapacity=Integer.MAX_VALUE maxPoolSize=Integer.MAX_VALUE keepAliveTime=60s allowCoreThreadTimeout=false rejectedExecutionHandler=AbortPolicy() ...
Java线程池及调优
HY1273383167的博客
04-08 2073
1. Java的线程池 ① 合理使用线程池的好处 Java的线程池是运用场景最多的并发框架，几乎所有需要异步或者并发执行任务的程序都可以使用线程池。 合理使用线程池能带来的好处： 降低资源消耗。 通过重复利用已经创建的线程降低线程创建的和销毁造成的消耗。例如，工作线程Woker会无线循环获取阻塞队列中的任务来执行。 提高响应速度。 当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。 线程是稀缺资源，Java的线程池可以对线程资源进行统一分配、调优和监控。 ② 线
Java | 多线程调优（上）：哪些操作导致了上下文切换？
sinat_27143551的博客
10-25 2863
我们常说“实践是检验真理的唯一标准”，这句话不光在社会发展中可行，在技术学习中也同样适用。记得我刚入职上家公司的时候，恰好赶上了一次抢购活动。这是系统重构上线后经历的第一...
java线程池调优小技巧
Ye_Xing_的博客
07-06 778
java线程调优小技巧
多线程之线程池实现---加优化
修国栋的博客
08-20 250
预备知识 线程概念 main函数和信号处理函数是同一个进程地址空间中的多个控制流程,多线程也是如此. 信号处理函数的控制流程指示在信号递达时产生,在处理完信号之后结束.而多线程的控制流程可以长期并存,操作系统在各个线程之间调度和切换. 同一进程的多个线程共享同一地址空间,因此,代码段,数据段都是共享的,只有栈是私有的. 头文件 #include <pthread.h> 在Linux下封装好的线程函数，通过 g++ ***.cpp -lpthread -o xxx 编译，./xxx 运行 win
使用线程池优化多线程编程
sanqima的专栏
06-05 1264
Java中的对象是使用new操作符创建的，如果创建大量短生命周期的对象，这种方式性能非常低下。为了解决这个问题，而发明了池技术。对于数据库连接有连接池，对于线程则有线程池。 本实例介绍两种方式创建1000个短生命周期的线程，第一种是普通方式，第二种是线程池的方式。通过时间和内存消耗的对比，就可以很明显地看出线程池的优势。
Java线程池参数优化详解和使用场景
王德昌的博客
08-11 380
线程池在Java多线程编程中扮演着重要的角色。它可以有效地管理和复用线程，避免频繁地创建和销毁线程带来的资源消耗。然而，在实际应用中，线程池的性能和稳定性往往需要根据具体的场景进行参数优化。本文将从线程池的原理入手，结合使用场景，详细介绍线程池的参数优化方法，并给出相应的示例代码和测试用例，加深对线程池的理解。通过本文的介绍，我们了解了Java线程池的原理、参数优化方法和使用场景。合理地设置线程池的参数，可以提高系统的性能和稳定性，提高系统的吞吐量和响应时间。
线程池优化
大黄蜂的博客
12-27 2249
线程池优化 如果从提高线程执行效率，来对多线程程序进行优化，自然让人联想到了线程池技术。 基本概念与原理 Java 线程池会生成一个队列，要执行的任务会被提交到这个队列中。有一定数量的线程会在队列中取任务，然后执行。 任务执行完毕以后，线程会返回任务队列，等待其他任务并执行。线程池中有一定数量的线程随时待命。 由于生成和维持这些线程是需要耗费资源了，维持太多或者太少的线程都会对系统运行效率造成影响...
C#多线程编程学习笔记
C#多线程编程不仅包括如何创建线程，还包括如何控制线程执行顺序，处理线程间通信，以及确保线程安全。通过学习这些示例，开发者可以掌握如何在实际项目中有效利用多线程，提高应用程序的性能和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值