Java学习日志(十): 多线程，创建多线程的三种方式

物联网 2020-02-09 10:18:05 阅读次数: 0

JavaEE学习日志持续更新----> 必看！JavaEE学习路线（文章总汇）

Java学习日志（十）

多线程

并发与并行

并发：两个或多个事件在同一个时间段内发生（交替执行）。
在这里插入图片描述
并行：两个或多个事件在同一个时刻发生（同时执行）。
在这里插入图片描述

进程与线程

进程：进入到内存中的程序。
在这里插入图片描述
线程：进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
在这里插入图片描述

线程调度

分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

用户可在任务管理器中的详细信息列表设置线程的优先级

主线程

主线程：执行main方法的线程，程序的执行从main方法开始，从上到下逐行执行

public class Person {
    private String name;

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

    public void run(){
        for (int i = 0; i < 20; i++) {
            System.out.println(name+"run"+i);
        }
    }
}
public class Demo01 {
    public static void main(String[] args) {
        Person p1 = new Person("aaa");
        p1.run();

        Person p2 = new Person("bbb");
        p2.run();
    }
}

java程序进入到内存中，JVM会先执行main方法，JVM会通过操作系统，开辟一条main方法通向cpu的路径，cpu通过这条路径执行main方法。这条路径的名字就叫主线程（main线程）。

创建多线程程序

创建多线程程序的第一种方式：继承thread类

java.lang.Thread:就是一个描述线程的类，类想实现多线程，就必须继承Thread类。
线程是程序中执行的线程。 Java虚拟机允许应用程序同时运行多个执行线程。

java程序属于抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个线程执行(线程随机性)

实现步骤：

  1. 创建Thread类的子类，继承Thread类
  2. 在Thread类的子类中，重写Thread类的run方法，设置线程任务(开启新的线程的目的)
  3. 创建Thread类的子类对象
  4. 调用Thread类中的start方法开启新线程，执行线程任务run方法

void start()： 导致此线程开始执行， Java虚拟机调用此线程的run方法。结果是两个线程同时运行：当前线程（主线程:执行main方法中的代码）和另一个线程（新的线程：执行其run方法中的方法）。不止一次启动线程永远不合法。 特别是，一旦完成执行，线程可能无法重新启动。—>start方法只能执行一次

示例：通过继承thread类，创建多线程程序

//1.创建Thread类的子类，继承Thread类
public class MyThread extends Thread{
    //2.在Thread类的子类中，重写Thread类的run方法，设置线程任务(开启新的线程的目的)

    @Override
    public void run() {
        //新线程执行run方法
        for (int i = 0; i < 20; i++) {
            System.out.println("run-->"+i);
        }
    }
}
public class Demo01Thread {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread mt = new MyThread();
        //mt.run(); 不会开启新线程
        mt.start();
        //main线程会继续执行for循环
        for (int i = 0; i < 20; i++) {
            System.out.println("main-->"+i);
        }

    }
}

新的线程和main线程优先级相同，cpu会随机执行某一个线程，就会出现随机性打印结果

run-->0
main-->0
main-->1
run-->1
main-->2
run-->2
main-->3
run-->3
main-->4
run-->4
run-->5
run-->6
run-->7
run-->8
run-->9
main-->5
run-->10
main-->6
run-->11
main-->7
run-->12
main-->8
run-->13
main-->9
run-->14
main-->10
run-->15
main-->11
main-->12
main-->13
main-->14
main-->15
main-->16
main-->17
run-->16
main-->18
run-->17
run-->18
run-->19
main-->19

随机性打印结果原理：

  1. JVM首先运行main方法，找到操作系统开辟一条通向cpu的路径，这个路径就是主线程，cpu通过这个路径就可以执行main
  2. 执行MyThread mt = new MyThread();，开辟一条新的通向cpu的路径。mt.start();用来执行run方法
  3. 现在有两条路径通向cpu，对于cpu而言就有了选择的权力，可以随机选择一个来执行（主线程和新线程的优先级相同），所以就有了随机性打印结果。
  4. 内存图解
    在这里插入图片描述

获取线程的名称

主线程:main
新线程:Thread-0,Thread-1…Thread-n

  1. 使用Thread类中的getName方法
    String getName() 返回此线程的名称。
public class MyThread extends Thread{
    @Override
    public void run() {
        //1.使用Thread类中的getName方法
        String name = getName();
        System.out.println(name);
  }
}
public class Demo01Thread {
    public static void main(String[] args) {
        //线程1
        MyThread myThread = new MyThread();
        myThread.start();//Thread-0
        //线程2
        new MyThread().start();//Thread-1
    }
}
  1. 可以先获取当前正在执行的线程，再通过getName获取线程名称
    static Thread currentThread() 返回对当前正在执行的线程对象的引用。
public class MyThread extends Thread{
    @Override
    public void run() {
       //2.可以先获取当前正在执行的线程，再通过getName获取线程名称
        Thread currentThread = Thread.currentThread();
        String name = currentThread.getName();
        System.out.println(name);
    }
}
public class Demo01Thread {
    public static void main(String[] args) {
        //线程1
        MyThread myThread = new MyThread();
        myThread.start();//Thread-0
        //线程2
        new MyThread().start();//Thread-1

        //获取主线程名称
        System.out.println(Thread.currentThread().getName());
    }
}

设置线程的名称

  1. 可以使用Thread的方法setName
    void setName​(String name) 将此线程的名称更改为等于参数 name 。
public class MyThread extends Thread{
 @Override
    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}
public class Demo01 {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.setName("aaa");
        mt.start();
    }
}
  1. 添加一个带参构造方法，参数传递线程的名称，调用父类的带参构造，把名字传递给父类
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 Demo01 {
    public static void main(String[] args) {
        MyThread mt2 = new MyThread("bbb");
        mt2.start();//bbb
    }
}

Thread类中的sleep方法

static void sleep​(long millis) 导致当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，具体取决于系统计时器和调度程序的精度和准确性。

示例：制作秒表

public class Demo01 {
    public static void main(String[] args) {
        //秒表
        for (int i = 0; i < 60; i++) {
            System.out.println(i);
            //让程序睡眠1s 1s=1000ms
            try {
                Thread.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

创建多线程程序的第二种方式：实现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方法
//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);
        }
    }
}
public class Demo01 {
    public static void main(String[] args) {
        //3.创建Runnable接口的实现类对象
        RunnableImpl r = new RunnableImpl();
        //4.创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(r);
        //5.调用Thread类中的start方法，开启新线程，执行run方法
        t.start();

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

实现Runnable接口的方式和继承Thread类方式不同

  1. 避免单继承的局限性
    一个类继承了Thread类，就不能继承其他类
    一个类实现了Runnable接口，还可以继承别的类，实现其他接口
  2. 增强了程序的扩展性
    实现Runnable接口，把设置线程任务（重写run方法目的就是设置线程任务
    和开启线程）和创建Thread对象（调用Start方法开启线程）
    进行了解耦，分离

创建多线程程序的第三种方式：匿名内部类

匿名内部类作用：简化代码

  • 把子类继承父类，重写父类方法，创建子类对象，合成一步完成
  • 把实现类继承实现接口，重写接口的方法，创建实现类对象，合成一步完成

格式：

new 父类/接口(){
        重写父类/接口中的方法
};

匿名内部类的方式实现多线程程序的三种方式：

  1. 父类Thread，new MyThread().start();
public class Demo01 {
    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()+"-->"+i);
                }
            }
        }.start();
    }
}
  1. 接口Runnable,new Thread(new RunnableImpl()).start() ;
public class Demo02 {
    public static void main(String[] args) {
        //接口Runnable
        //new Thread(new RunnableImpl()).start() ;

        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 20; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        }).start();
    }
}

3.Lambda 简化内部类

public class Demo03 {
    public static void main(String[] args) {
	//Lambda 简化内部类
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                System.out.println(Thread.currentThread().getName()+"-->"+i);
            }
        }).start();
    }
}
Sakuraaaaaaa
发布了14 篇原创文章 · 获赞 15 · 访问量 1606
私信 关注

猜你喜欢

转载自blog.csdn.net/Sakuraaaaaaa/article/details/104208714
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022