19:异常与多线程---线程的实现方式

于 2020-02-20 17:16:58 发布
阅读量159 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hhytyq/article/details/104393638
版权

一:并发和并行

并发:指两个或者多个事件在同一时间段内发生。
并行:指两个或者多个事件在同一时刻发生(同时发生)

二:进程概念

进程:是指一个内存运行的应用程序，每个进行都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，市系统运行程序的基本单位；系统运行一个程序即是一个进程从创建，运行到消亡的过程。
线程:线程是进程的一个执行单位，负责当前进程中程序的执行，一个进程至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称为多线程程序。
简而言之:一个程序运行后至少有一个进程，一个进程可以包含多个线程。

三:线程概念:

线程属于进程，是进程中的一个执行单元，负责程序的执行。
在这里插入图片描述

四:主线程

Person类

package cn.itcast.day10.Demo;

public class Person {
    private String name;

    public void run(){
        //定义循环，执行20次
        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;
    }
}

Demo01MainThread类

package cn.itcast.day10.Demo;
/*
    主线程:执行主(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();
    }
}

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

五:创建多线程程序的第一种方式

java使用java.lang.Thread类代表线程,所有的线程对象必须是Thread类或者其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下:
1:定义Thread类的子类，并重写该类的run方法，该类run()方法的方法体就代表线程需要完成的任务，因此把run()方法称为线程执行体。
2:创建Thread子类的实例，即创建 了线程对象。
3:调用线程对象的start()方法来启动该线程。
MyThread类

package cn.itcast.day10.Demo;
//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);
        }
    }
}

Demo01Thread类

package cn.itcast.day10.Demo;
/*
    创建多线程的第一种方式:创建Thread类的子类
    java.lang.Thread类:是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
    实现步骤:
        1:定义Thread类的子类，并重写该类的run方法，该类run()方法的方法体就代表线程需要完成的任务，因此把run()方法称为线程执行体。
        2:创建Thread子类的实例，即创建 了线程对象。
        3:调用线程对象的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);
        }
    }
}

在这里插入图片描述

六:多线程原理_随机打印结果

![在这里插入图片描述](https://img-blog.csdnimg.cn/2020021917005098.png?x-oss-process=image/w atermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hoeXR5cQ==,size_16,color_FFFFFF,t_70)

七:多线程原理_多线程内存图解

在这里插入图片描述

八:Thread类的常用方法_获取线程名称

Thread的构造方法:

public Thread();//分配一个新的线程对象。
public Thread(String name);//分配一个指定名字的新的线程对象
public Thread(Runnable target);分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name);分配一个带有指定目标新的线程对象并指定名字。

常用方法:

  public String getName();获取当前线程名称
  public void start();导致此线程开始执行；java虚拟机调用此线程的run()方法
  public void run();此线程要执行的任务在此定义代码
  public static void sleep(long mills);使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行).
  public static Thread currentThread();返回对当前正在执行的线程对象的引用。

MyThread类

/*
    获取线程的名称:
        1:使用Thread类中的gtName()
            String getNaem();返回该线程的名称。
        2:可以先获取当前正在执行的线程，使用线程的方法getName()获取线程的名称。
            static Thread curentThread()返回对当前正在执行的线程对象的引用。
*/
//定义一个Thread类的子类
public class MyThread extends Thread{
    //重写Thread类中的run方法，设置线程任务。
    @Override
    public void run(){
        //设置线程名称
      /*  String name =getName();
        System.out.println(name);*/
     /* Thread t =Thread.currentThread();
      String name =t.getName();
      System.out.println(name);*/
     //链式编程
        System.out.println(Thread.currentThread().getName());
    }

}

Demo01GetThreadName类

/*
    线程的名称:
        主线程: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();
        new MyThread().start();
        System.out.println(Thread.currentThread().getName());//获取主线程。
    }
}

九:Thread类的常用方法_设置线程名称

/*
    设置线程的名称(了解)
        1:使用Thread类中的setName(名字)
            void setName(String naem)改变线程名称，使之与参数name相同。
        2:创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，让父类*Thread)给子类线程起一个名字
            Thread(String name);分配新的Threead对象。
*/
public class MyThread extends Thread {
    public MyThread(){}
    public MyThread(String name ){
        super(name);
    }
    @Override
    public void run() {
        //获取线程名称
        System.out.println(Thread.currentThread().getName());
    }
}


public class Demo01GetThreadName {
    public static void main(String[] args) {
        //开启多线程
        MyThread mt =new MyThread();
        mt.setName("小强");
        mt.start();
        //开启多线程
        new MyThread("旺财").start();
    }
}

在这里插入图片描述

十:Thread类的常用方法_sleep

/*
      public static void sleep(long mills);使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行).
*/
public class Demo01Sleep {
    public static void main(String[] args) {
        //模拟秒表
        for (int i=1;i<=100;i++){
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒钟。
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

十一:创建线程的方式二

采用java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
步骤如下:
1:定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
2:创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
3:调用线程对象的start()方法来启动线程。
RunnableImpl类

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

Demo01Runnable类

/*
   创建多线程程序的第二种方式:实现Runnable接口
   java.lang.Runnable
    Runnable   接口应该由哪些打算通过某个线程执行其实例的类来实现。
    类必须定义一个为run的无参数方法
    java.lang.Thread类的构造方法
        Thread(Runnable targeet)分配新的target对象，

     实现步骤:
        1:创建一个Runnable接口的实现类
        2:在实现类中重写Runnabe接口的run方法，设置线程任务。
        3:创建一个Runnable接口的实现类对象
        4:创建Thread对象，构造方法传递Runnable接口的实现类对象。
        5:调用Thread类中的start方法，开启新的线程run方法
*/
public class Demo01Runnable {
    public static void main(String[] args) {
        //3:创建一个Runnable接口的实现类对象
         RunnableImpl run =new RunnableImpl();
         //4:创建Thread对象，构造方法传递Runnable接口的实现类对象。
        Thread t =new Thread(run);
        //5:调用Thread类中的start方法，开启新的线程run方法
        t.start();

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

在这里插入图片描述

十二:Thread和Runnabel的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnabel接口的话，则很容易的实现资源共享。
总结:
实现Runnabel接口比继承Thread类所具有的优势:
1:适合多个相同的程序代码的线程共享同一资源。
2:可以避免java中的单继承的局限性
3:增加程序的键壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
4:线程池只能放入实现Runnable或Callabel类线程，不能直接放入继承Thread的类。
扩充:在java中，每次程序运行至少启动2个线程。一个是main线程，一个垃圾收集线程。因为每当使用java命令执行一个类的时候，实际都会启动

一个JVM,每一个JVM其实就是在操作系统中启动了一个进程。 十三:匿名内部类方式实现线程的创建

/*
    匿名内部类方式实现线程的创建:
        匿名:没有名字
        内部类：在其他类内部的类
    匿名内部类作用:简化代码
        把子类继承父类，重写父类的方法，创建子类对象合一步完成。
        把实现类实现接口，重写接口中的方法，创建实现类对象合一步完成。
    匿名内部类的最终产物:子类/实现类对象，而这个类没有名字。
    格式:
    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()+"hello");
                }
            }
        }.start();

        //线程的接口Runnabel
        //RunnabelImpl r =new RunnableImpl();
       Runnable r = new Runnable(){
            //重写run方法，设置线程任务。
            @Override
            public void run() {
                for(int i=0;i<20;i++){
                    System.out.println(Thread.currentThread().getName()+"world");
                }
            }
        };
       new Thread(r).start();
       //简化接口的方式:
        new Thread(new Runnable(){
                    //重写run方法，设置线程任务。
                    @Override
                    public void run() {
                        for(int i=0;i<20;i++){
                            System.out.println(Thread.currentThread().getName()+"代码");
                        }
                    }
                }).start();
    }
}
是翼不是一
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值