1-7 异常与多线程\第2节 线程实现方式

于 2020-07-09 20:09:27 发布
阅读量85 收藏
点赞数
分类专栏： 0、Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42788016/article/details/107236533
版权

这里写自定义目录标题

P31008_并发与并行

在这里插入图片描述
在这里插入图片描述
并发，交替执行。

在这里插入图片描述

在这里插入图片描述

P31210_进程概念

P31311_线程概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

P31412_线程调度

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

P31513_主线程

package com.itheima.demo05.Thread;

public class Person {
    private String name;

    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println(name+"->"+i);
        }
    }
    
    public Person() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package com.itheima.demo05.Thread;
/*
    主线程：执行主Main方法的线程

    单线程程序：java程序中只有一个线程
    执行main方法开始，从上到下一次执行

    JVM执行main方法，main方法会进入到栈内存
    JVM会找到操作系统开辟一条main方法通向cpu的执行路径
    cpu就可以通过这个路径来执行main方法
    而这个路径有一个名字，交main主线程
 */
public class Demo01MainThread {
    public static void main(String[] args) {
        Person p1 = new Person("小强");
        p1.run();
        System.out.println(0/0);
        Person p2 = new Person("小强");
        p2.run();


    }
}

System.out.println(0/0);
在这里插入图片描述
单线程，发生异常会停止程序。
后面学习多线程，可以发现异常，并执行后面的程序。

P31614_创建多线程程序的第一种方式_创建Thread类的子类

在这里插入图片描述

package com.itheima.demo06.Thread;
//1.创建一个Thread类的子类
public class MyThread extends Thread{
    //2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run"+i);
        }
    }
}


package com.itheima.demo06.Thread;
/*
    创建多线程程序的第一种方式：创建Thread类的子类
    java.lang.Thread类：描述线程的类，我们想要实现多线程的程序，就必须继承Thread

    实现步骤：
        1.创建一个Thread类的子类
        2.在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)
        3.创建Thread类中的子类对象
        4.调用Thread类中的方法start方法，开启新的线程，执行run方法
            void start()使得该线程开始执行。java虚拟机调用该线程的run方法。
            结果是两个线程并发地进行；当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)。
            多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
     java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行；
     同一个优先级，随机选择一个执行
 */
public class Demo01Thread {
    public static void main(String[] args) {
        //3.创建Thread类中的子类对象
        MyThread mt = new MyThread();
        //4.调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main"+i);
        }
    }
}

P31701_线程安全问题的概述

--------视频顺序有错误，已经纠正

P30301_多线程原理_随机性打印结果


public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run"+i);
        }
    }
}


package demo05;

public class Demo01Thread {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main"+i);
        }
    }
}

在这里插入图片描述

P30402_多线程原理_多线程内存图解

mt.start();他会开辟新的栈空间。
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

P30503_Thread类的常用方法_获取线程名称的方法

在这里插入图片描述

package com.itheima.demo01.getName;
/*
    获取线程的名称：
        1.使用Thread类中的方法getName()
            String getName() 返回该线程的名称。
        2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
            static Thread currentThread() 返回对当前正在执行的线程对象的引用
 */
//定义一个Thread类的子类
public class MyThread extends Thread {
    //重写Thread类中的run方法，设置线程任务

    @Override
    public void run() {
//        super.run();
//第一种
        //获取线程的名称
       String name = getName();
       System.out.println(name);
	   
//第二种
        Thread t = Thread.currentThread();
        System.out.println(t);//Thread[Thread-0,5,main]

        String name = t.getName();
        System.out.println(name);

//第三种
        //链式编程
        System.out.println(Thread.currentThread().getName());
    }
}


package com.itheima.demo01.getName;
/*
    线程的名称：
        主线程：main
        新线程：Thread-0,Thread-1,Thread-2
 */
public class Demo01GetThreadName {
    public static void main(String[] args) {
        //创建Thread类的子类对象
        MyThread mt = new MyThread();
        //调用start方法，开启新线程，执行run方法
        mt.start();
        new MyThread().start();

        //获取主线程的名称
        System.out.println(Thread.currentThread().getName());
        //Thread.currentThread()获取当前正在使用的线程
    }
}

P30604_Thread类的常用方法_设置线程名称的方法

如果不设置线程名字，出现Thread-0类似这种。

package com.itheima.demo02.setName;
/*
    设置线程的名称：(了解)
        1.使用Thread类中的方法setName(名字)
            void setName(String name) 改变线程名称，使之参数name相同。
        2.创建一个带参数的构造方法，参数传递线程的名称;
            调用父类的带参构造方法，把线程名称传递给父类，让父类(Thread)给子线程起一个名字
            Thread(String name)分配新的Thread对象

 */
public class MyThread extends Thread{
    public MyThread(){}

    public MyThread(String name){
        super(name);//把线程名称传递给父类,让父类(Thread)给子线程起一个名字
    }

    @Override
    public void run() {
        //获取线程的名称
        System.out.println(Thread.currentThread().getName());
    }
}


package com.itheima.demo02.setName;

public class Demo01SetThreadName {
    public static void main(String[] args) {
        //开启多线程
        MyThread mt = new MyThread();
        mt.setName("校区");
        mt.start();

        //开启多线程
        new MyThread("嫂子").start();
    }
}

P30705_Thread类的常用方法_sleep

package com.itheima.demo03.sleep;
/*
    public static void sleep(long millis):使得当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
    毫秒数结束之后，线程继续执行
 */
public class Demo01Sleep {
    public static void main(String[] args) {
        //模仿秒表
        for (int i = 1; i <=60 ; i++) {
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠一秒钟
            try {
                Thread.sleep(1000);//因为它是静态方法，所以可以直接Thread点
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

P30806_创建多线程程序的第二种方式_实现Runnable接口

在这里插入图片描述
在这里插入图片描述
因为Runable没有start方法，所以需要传给Thread，然后通过Thread的start方法。

package com.itheima.demo04.Runnable;
//1.创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //2.在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
    }
}


package com.itheima.demo04.Runnable;
/*
    创建多线程程序的第二种方式：实现Runnable接口
    java.lang.Runnable
        Runnable接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为run的无参数构造方法。
    java.Lang.Thread类的构造方法
        Thread(Runnable target)分配新的Thread对象
        Thread(Runnable target, String name)分配新的Thread对象。
    实现步骤：
        1.创建一个Runnable接口的实现类
        2.在实现类中重写Runnable接口的run方法，设置线程任务
        3.创建一个Runnable接口的实现类对象
        4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        5.调用Thread类中的start方法，开启新的线程执行run方法

    实现Runnable接口创建多线程程序的好处：
        1.避免了单继承的局限性
            一个类只能继承一个类(一个人只能有一个亲爹)，类继承Thread类就不能继承其他的类
            实现了Runnable接口，还可以继承其他的类，实现其他接口
        2.增强了程序的扩展性，降低了程序的耦合性(解耦)
            实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离(解耦)
            实现类中，重写了run方法：用来设置新线程任务
            创建Thread类对象，调用start方法：用来开启新线程
 */
public class Demo01Runnable {
    public static void main(String[] args) {
        //3.创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();

        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
//        Thread t = new Thread(run);//打印线程名称
        Thread t = new Thread(new RunnableImpl2());//打印Hello，这里进行了任务分离，所以runnable更好。
        //5.调用Thread类中的start方法，开启新的线程执行run方法
        t.start();

        for (int i = 0; i < 20; i++) {
            System.out.println(Thread.currentThread().getName()+"->"+i);
        }
    }
}

P30907_Thread和Runnable的区别_bilibili

在这里插入图片描述

也可以不写接口，直接使用匿名内部类。

在这里插入图片描述
在这里插入图片描述

package com.itheima.demo05.InnerClassThread;
/*
    匿名内部类方式实现线程的创建

    匿名：没有名字
    内部类：写在其他类内部的类

    匿名内部类的作用：简化代码
        把子类继承父类，重写父类方法，创建子类对象一步完成
        把实现类实现类接口，重写接口中的方法，创建实现类对象一步完成
    匿名内部类的最终产物：子类/实现类对象，而这个类没有名字

    格式：
        new 父类/接口(){
            重复父类/接口中的方法
        };
 */
public class Demo01InnerClassThread {
    public static void main(String[] args) {
        //线程的父类是Thread
        //之前我们是这么写的：new MyThread().start();
        //现在用匿名内部类
        new Thread(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
                }
            }
        }.start();

        //线程的接口Runnable
        //以前我们还需要，Runnable r = new RunnableImpl();//多态
        //接口不可以创建对象，这个是你匿名内部类。new Runnable(){}。注意这里有{}
        Runnable r = new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"秃头佬");
                }
            }
        };
        new Thread(r).start();

        //再进一步简化，但是不好看。把r去掉，之间把{};里面的东西传入new Thread(r).start的r中
        new Thread(new Runnable(){
            //重写run方法,设置线程任务
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+"awsl");
                }
            }
        }).start();
    }
}

currentThread干嘛的？
返回对当前的线程的引用。
public class Test {
    public static void main(String[] args) {
        new MyThread().start();
        System.out.println(Thread.currentThread());
    }
}

public class MyThread extends Thread{
@Override
public void run() {

    for (int i = 0; i < 2; i++) {
        System.out.println(Thread.currentThread().getName()+"->"+i);
    }
     System.out.println(Thread.currentThread());
}
}

Thread[main,5,main]
Thread[Thread-0,5,main]

[线程名称, 线程优先级, 线程所属线程组]

直接只用匿名内部类

public static void main(String[] args) {
        new Thread(){
            @Override
            public void run() {
                System.out.println();
            }
        }.start();

        new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println();
            }
        }).start();
    }
勤能补拙索大隆
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值