2022-08-02 学习日记（22nd day）多线程--第一天

于 2022-08-02 19:50:25 发布
阅读量297 收藏
点赞数 1
分类专栏： java学习日记 文章标签： 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49627122/article/details/126124324
版权

目录

创建线程：

继承Thread类

实现Runnable接口

使用箭头函数（Lambda表达式）

实现Callable接口

守护线程

线程的生命周期

指令重拍

内存屏障

可见性

线程争抢

栗子一： 

栗子二：

线程安全的实现方法

创建线程：

在Java中，创建线程有三种方式。

  1. 继承Thread类，并且重写run方法
  2. Thread类中的run方法不是抽象方法
  3. Thread类也不是抽象类

继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("重写的run方法");
        System.out.println("2");
    }
}
public class Test01 {
    public static void main(String[] args){
        MyThread myThread = new MyThread();
        //当调用start方法启动一个线程时，会执行重写的run方法的代码
        //调用的是start，执行的是run,为什么不直接调run。
        //因为对象.方法就不叫启动线程，那就是简单的对象调用方法。
        System.out.println(1);
        myThread.start();//启动线程
        //myThread.run();//对象调方法
        //线程的优先级,主方法相当于一个线程，然后我们又启动了一个线程MyThread，主方法的优先级高。就先执行优先级高的。
        //线程的优先级是个概率问题，做不到100%
//        百分之九十会先跑主方法，10%先跑myThread。
        System.out.println(3);
        System.out.println(4);

    }
}

 运行结果：

这样就很直观的看出，线程是有执行顺序的。

现在这个MyThread继承了Thread类之后，它就是一个独立的线程。

要让线程“启动”，调用线程的start方法。

实现Runnable接口

Runnable接口里只有一个抽象方法：run()

class MyThread2 implements Runnable {
    @Override
    public void run() {
        System.out.println("继承了Runnable接口后，我创建了MyThread2");
    }
}

public class Test02 {
    public static void main(String[] args) {
        MyThread2 myThread2 = new MyThread2();
        //如果想要让线程启动，必须调用Thread类中的start方法
//        问题：实现了Runnable接口，找不到start方法了？
        Thread t=new Thread(myThread2);
        t.start();
    }
}

使用箭头函数（Lambda表达式）

public class Test03 {
    public static void main(String[] args) {
        System.out.println(1);
        //箭头函数接口，抽象类，重写方法
        new Thread(()-> System.out.println(2)).start();
        try {
            Thread.sleep(1000);//线程休眠---毫秒
        } catch (InterruptedException e) {//线程中断异常
            throw new RuntimeException(e);
        }
        System.out.println(3);
        System.out.println(4);
    }
}

 Thread.sleep(1000)-----线程休眠1秒。但是会有异常，所以需要抛出。

实现Callable接口

Callable是泛型，里面只有一个抽象方法：call

class MyThread3 implements Callable<String>{

    @Override
    public String call() throws Exception {
        System.out.println(2);
        return "Call方法的返回值";
    }
}
public class Test04 {
    public static void main(String[] args) {
        System.out.println(1);
        //Callable-->FutureTask-->RunnableFuture-->Runnable-->Thread
        FutureTask<String> futureTask = new FutureTask<>(new MyThread3());//也是个泛型类
        new Thread(futureTask).start();
        System.out.println(3);
        System.out.println(4);
    }
}

小结：

Runnable和Callable都得通过Thread类调用start方法来启动线程，他们并不能使用自己的方法启动线程 ，Runnable没有返回值，而Callable的方法有返回值。

守护线程

Java中提供了两种类型的线程

  1. 用户线程
  2. 守护程序线程

守护线程是为用户线程提供服务，仅在用户线程运行时才需要。

守护线程对于后台支持任务非常有用。

垃圾回收：大多数JVM线程都是守护线程。 

任何线程继承创建它的线程守护进程状态。由于主线程是用户线程,因此在main方法内启动的任何线程默认都是守护线程

守护线程的创建：

public class Test05 extends Thread{
    @Override
    public void run() {
        super.run();
    }

    public static void main(String[] args) {
        Test05 test05 = new Test05();
        test05.setDaemon(true);
        //这就变成了守护线程
    }
}

线程的生命周期

  • NEW:这个状态主要是线程未被start调用执行
  • RUNNABLE:线程正在JVM中被执行，等待来自操作系统的调度
  • BLOCKED：阻塞，因为某些原因，不能立即执行需要挂起等待。
  • WAITING：无期限等待，Object类。如果没有唤醒，则一直等待。
  • TIMED_WAITING:有限期等待，线程等待一个指定的时间
  • TERMINATED：终止线程的状态，线程已经执行完毕。

等待和阻塞两个概念有点像，阻塞因为外部原因，需要等待 

而等待一般是主动调用方法，发起主动的等待。等待还可以传入参数确定等待时间。

public static void main(String[] args) {
        Thread t1 = new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    Thread.sleep(100);
                    System.out.println("这是线程一"+i);;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }});
        Thread t2 = new Thread(()->{
            for (int i = 0; i <10 ; i++) {
                try {
                    Thread.sleep(100);
                    System.out.println("这是线程二"+i);;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }});

        t1.start();
        t2.start();
        try {
            //t1插队
            t1.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-------------");
        //分割线出现的位置，join方法的本意阻塞线程
    }

指令重拍

尽量做到硬件和操作系统之间达到一致的访问效果。

内存屏障

我们发现测试结果中大部分感觉是正确的（0，1）或（1，0） 按道理来说绝对不会出现（0，0），如果出现（0，0）代表存在指令重排，乱序执行 使用volatile关键字保证一个变量在一次读写操作时，避免指令重排 我们在读写操作之前加入一条指令，当CPU碰到这条指令时必须等到前面的指令执行完，才能执行下一条指令

public class Test02 {
    private static int x=0,y=0;
    private static int a=0,b=0;
    private static int count =0;

    private static volatile int NUM=1;
    public static void main(String[] args) throws InterruptedException {
        long start=System.currentTimeMillis();
        for(;;){
            Thread t1=new Thread(()->{
                a=1;
                x=b;
            });
            Thread t2=new Thread(()->{
                b=1;
                y=a;
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("一共执行了"+count+++"次");
            if(x==0&&y==0){
                long end = System.currentTimeMillis();
                System.out.println("耗时"+(end-start)+"毫秒"+x+","+y);
                break;
            }
            a=0;b=0;x=0;y=0;
        }
    }
}

可见性

thread线程一直在高速读取缓存中的isOver，不能感知主线程已经把isOver改变了

这就是线程的可见性的问题

怎么解决？

volatile，能强制改变变量的读写直接在内存中，操作

public class Test03 {
    private volatile static boolean isOver=false;
    private static int number=0;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while(!isOver){

                }
                System.out.println(number);
            }
        });
        thread.start();
        Thread.sleep(1000);
        number = 50;
        //我已经改了，应该能退出循环了
        isOver = true;
    }
}

线程争抢

解决线程争抢的问题最好的办法就是【加锁】

synchronized 同步锁，线程同步

栗子一： 

public class Test04 {
    private static int count=0;

    public synchronized static void add(){
        count++;
    }

    public static void main(String[] args) throws InterruptedException{
        Thread t1=new Thread(()->{
            for (int i = 0; i <10000 ; i++) {
                add();
            }
        });
        Thread t2=new Thread(()->{
            for (int i = 0; i <10000 ; i++) {
                add();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最后的结果是"+count);
    }
}

 栗子二：

public class Ticket implements Runnable{

    private static final Object lock = new Object();

    private static Integer count = 100;

    String name;

    public Ticket(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        while(Ticket.count > 0){
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (Ticket.lock){
                System.out.println(name + "出票一张，还剩：" + Ticket.count-- + "张！");
            }
        }
    }

    public static void main(String[] args) {
        Thread one = new Thread(new Ticket("一号窗口"));
        Thread two = new Thread(new Ticket("二号窗口"));

        one.start();
        two.start();
    }
}

线程安全的实现方法

（1）数据不可变。
        一切不可变的对象一定是线程安全的。
        对象的方法的实现方法的调用者，不需要再进行任何的线程安全的保障措施。
        比如final关键字修饰的基本数据类型，字符串。
        只要一个不可变的对象被正确的创建出来，那外部的可见状态永远都不会改变。
（2）互斥同步。加锁。【悲观锁】
（3）非阻塞同步。【无锁编程】，自旋。我们会用cas来实现这种非阻塞同步。
（4）无同步方案。多个线程需要共享数据，但是这些数据又可以在单独的线程中计算，得出结果
        我们可以把共享数据的可见范围限制在一个线程之内，这样就无需同步。把共享的数据拿过来，
        我用我的，你用你的，从而保证线程安全。ThreadLocal

public class Ch05 {

    private final static ThreadLocal<Integer> number = new ThreadLocal<>();

    private static int count = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // t1内部自己用一个count
                number.set(count);
                for (int i = 0; i < 10; i++) {
                    number.set(count ++);
                    System.out.println("t1-----" + number.get());
                }
            }
        });
        Thread t2= new Thread(new Runnable() {
            @Override
            public void run() {
                // t2内部自己用一个count
                number.set(count);
                for (int i = 0; i < 10; i++) {
                    number.set(count ++);
                    System.out.println("t2-----" + number.get());
                }
            }
        });
        t1.start();
        t2.start();
    }
}

激进的土豆
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值