多线程笔记

于 2021-05-05 18:45:09 发布
阅读量57 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43821927/article/details/116428375
版权

目录

程序、进程和线程

我们写好的程序是静态的，程序跑起来之后就变成了进程是动态的，进程之下又有线程，如main()方法是我们自己写的称之为用户线程，gc垃圾回收机制则称之为守护线程。

创建线程

方法一:继承Thread类

继承Thread类，重写run()方法，调用start开启线程

public class ThreadTest01 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("run线程---"+i);
        }
    }

    public static void main(String[] args) {
        new ThreadTest01().start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程---"+i);
        }
    }
}

注意：线程开启不一定立即执行，由cpu调度执行

方法二：实现Runnable接口

实现Runnable接口，重写run()方法，执行线程需要丢入Runnable接口实现类，调用start方法。
为什么有了方法一还会有方法二？因为在java中是单继承的，当类B继承了类A，这时候又想让类B实现多线程就不能再用继承Thread的方式了。

public class ThreadTest02 implements Runnable {
    @Override
    public void run() {
        //run方法线程体
        for (int i = 0; i < 200; i++) {
            System.out.println("run线程---"+i);
        }
    }

    public static void main(String[] args) {
        //创建Runnable接口的实现类对象
        ThreadTest02 threadTest02 = new ThreadTest02();
        //创建线程对象，通过线程对象来开启我们的线程，代理
        new Thread(threadTest02).start();

        for (int i = 0; i < 1000; i++) {
            System.out.println("main线程---"+i);
        }
    }
}

练习：经典火车票

public class ThreadTest04 implements Runnable {
    private int ticketNum = 15;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"------>拿到了第"+ticketNum--+"张票");
        }
    }

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

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

结果会出现两个人拿同一张票的情况，多线程同时操作一个资源的情况下，会出现线程不安全，数据紊乱的问题。
在这里插入图片描述
解决办法：使用synchronized修饰代码块

public void run() {
    while (true) {
        synchronized(this) {
            if (ticketNum <= 0){
                System.out.println(Thread.currentThread().getName()+"------>没票了");
                break;
            }
            System.out.println(Thread.currentThread().getName()+"------>拿到了第"+ticketNum--+"张票");
        }
        //模拟延迟
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Lambda表达式

如何一步一步简化成lambda表达式

public class TestLambda1 {
    //3.静态内部类
    static class Like2 implements Ilike {

        @Override
        public void likeLambda() {
            System.out.println("I like lambda2");
        }
    }

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

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

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

            @Override
            public void likeLambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.likeLambda();

        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        like = new Ilike() {
            @Override
            public void likeLambda() {
                System.out.println("I like lambda4");
            }
        };
        like.likeLambda();

        //6.用lambda简化
        like = () -> {
            System.out.println("I like lambda5");
        };
        like.likeLambda();

    }
}

//2.实现类
class Like implements Ilike {

    @Override
    public void likeLambda() {
        System.out.println("I like lambda1");
    }
}

//1.定义一个函数式接口：一个接口只有一个方法
interface Ilike {
    void likeLambda();
}

另外一个例子和总结

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = (a, b) -> {
            System.out.println("I love you-->" + a + "," + b);
        };
        love.love(520, "DoubleQ");
        love = (a, b) -> System.out.println(a + "," + b);
        love.love(521, "Chason");

        ILove2 love2 = a -> {
            System.out.println("I love2 you-->" + a);
        };
        love2.love(520);
    }
    //总结：
    //lambda表达式在只有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
    //使用lambda的前提是接口为函数式接口
    //多个参数也可以去掉参数类型，要去掉就都去掉，不去就都不去，必须加上括号，只有一个参数可以不加括号但是参数类型必须去掉。
}

interface ILove {
    void love(int a, String str);
}

interface ILove2 {
    void love(int a);
}

静态代理模式（婚庆公司为例）

//静态代理模式总结：
//真实对象和代理对象要实现同一个接口
//代理对象要代理真实角色

//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("真开心")).start();
        new WeddingCompany(new You()).happyMarry();
//        WeddingCompany weddingCompany = new WeddingCompany(new 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 before() {
        System.out.println("结婚前，婚庆公司帮老表筹备婚礼");
    }

    private void after() {
        System.out.println("结婚后，老表付尾款");
    }
}

线程休眠_sleep

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

//模拟倒计时
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("HHmmss").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;
            }
        }
    }
}

线程霸占_join

join霸占所有资源为自己所用，用完之后才把资源让出来给别人。
200之前vip线程和mian线程是可以互相抢夺资源进行打印输出语句的，当vip线程使用了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 {
        Thread thread = new Thread(new TestJoin());
        thread.start();

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

线程状态

大致可以概括成：新生、运行、阻塞、等待、死亡等状态。
在这里插入图片描述

线程优先级

线程优先级低只是意味着获得调度的概率低，并不一定会按照优先级的顺序来执行

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(3);
        t3.start();

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

        t5.setPriority(8);
        t5.start();

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


}

class MyPriority implements Runnable {

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

守护线程

虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕

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++) {
            if (i == 0){
                System.out.println("======Hello world!======");
            }
            System.out.println("你一生都开心地活着");
        }
        System.out.println("======Goodbye!World!======");
    }
}
Double_Q74280967
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程笔记多线程笔记
09-18
使用java.lang.Thread类或者java.lang.Runnable接口编写代码来定义、实例化和启动新线程。 一个Thread类实例只是一个对象，像Java中的任何其他对象一样，具有变量和方法，生死于堆上。 Java中，每个线程都有一个调用栈，即使不在程序中创建任何新的线程，线程也在后台运行着。 一个Java应用总是从main()方法开始运行，mian()方法运行在一个线程内，它被称为主线程。 一旦创建一个新的线程，就产生一个新的调用栈。 线程总体分两类：用户线程和守候线程。
Java多线程笔记
03-11
多线程学习笔记，好资源。包括线程基础等知识多线程学习笔记，好资源。包括线程基础等知识
马士兵多线程笔记.zip
02-21
马士兵多线程训练营上课笔记
java多线程笔记
12-10
Java线程的知识点总结。doc
java中的多线程笔记
07-08
java中的多线程笔记
多线程（3）—— 并发、同步、三大安全因素、锁
tian_彡
06-30 214
并发： 两个或多个事件在同一时间间隔发生（同一个对象被多个线程同时操作） 同步： 多个任务情况下，一个任务A执行结束，才可以执行另一个任务B。同一时间只存在一个线程 并发、同步、锁线程同步三大线程不安全案例不安全的买票问题不安全的银行取款问题线程不安全的集合解决线程不安全问题synchronized关键字Lock (锁)synchronized与Lock的对比死锁 线程同步 处理多线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时候我们就需要线程同步，线程同步其实就是等待机制 ,多个需要
狂神说java多线程笔记
最新发布
10-11
狂神在他的Java多线程笔记中，详细介绍了Java多线程的相关知识，包括线程的创建、启动、停止、等待、唤醒等操作，以及线程安全、锁、同步等概念和技术。 在Java多线程中，线程的创建有两种方式：继承Thread类和实现...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值