javaee——学习线程&java中线程对象的创建及多线程的简单使用

ly1573焯

于 2023-04-01 17:54:31 发布

阅读量223

点赞数

文章标签： jvm java 开发语言

本文链接：https://blog.csdn.net/weixin_53714478/article/details/129871806

版权

（2）实现Runnable接口，重写run方法

（3）通过创建Thread类的匿名内部类的方式创建线程

（4）通过创建Runnable接口的匿名内部类的方式来创建线程

（5）通过Lambda表达式的方式创建一个线程

一，什么是线程

1，线程的出现：

由于计算机技术的发展，进程的弊端也逐渐明显，由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入线程

2，线程的概念：

是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

3，线程与进程的区别：

进程是申请资源的最小单位
线程是CPU调度的最小单位
进程中包含线程，一个进程中最少有一个主线程
同一个进程下的线程共享进程申请的资源
进程内的线程如果崩溃了的话，就会影响到线程

4，线程的优势：

线程创建的速度比进程快
线程销毁的速度比进程快
线程的调度比进程快

二，线程的创建

1，java创建线程的步骤：

java创建一个线程对象——>JVM调用系统API——>创建一个操作系统中的线程（CPU上执行的线程）

2，java创建线程的方法

（1）继承Thread类，重写run方法

//通过继承thread类的方式来创建一个线程
class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello thread...");
    }
}
public class Demo_101 {
    public static void main(String[] args) {
        //实例化MyThread对象
        MyThread myThread = new MyThread();
        //线程启动
        myThread.start();
    }
}

（2）实现Runnable接口，重写run方法

//通过实现Runnable接口的方式创建线程
class MyRunnable implements Runnable{
    //定义线程要执行的任务
    @Override
    public void run() {
        System.out.println("run Runnable");
    }
}

public class Demo103 {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

（3）通过创建Thread类的匿名内部类的方式创建线程

public static void main(String[] args) {
        Thread  thread = new Thread(){
            @Override
            public void run() {
                System.out.println("通过创建Thread类的匿名内部类的方式创建线程");
            }
        };
        thread.start();
    }

（4）通过创建Runnable接口的匿名内部类的方式来创建线程

public static void main(String[] args) {
        Thread  thread = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println("通过创建Runnable接口的匿名内部类的方式来创建线程");
            }
        });
        thread.start();
    }

（5）通过Lambda表达式的方式创建一个线程

public static void main(String[] args) {
        Thread thread = new Thread(()->{
            System.out.println("通过Lambda表达式的方式创建一个线程"+count);
        });
        thread.start();
    }

3，java线程的简单使用

（1）多线程与单线程的区别：

单线程：

public static void main(String[] args) throws InterruptedException {
        while(true){
            System.out.println("进入循环");
            Thread.sleep(1000);
            if(false){
                break;
            }
        }
        System.out.println("主线程结束");
    }

执行结果

单线程无法跳出循环去执行后续代码

多线程：

public static void main(String[] args) {
        Thread thread = new Thread(()->{
            int count = 0;
            while(true){
                count++;
                System.out.println("通过Lambda表达式的方式创建一个线程"+count);
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        System.out.println("主线程执行完毕");
    }

执行结果：

多线程可以让一个线程执行循环，主线程可以执行后续代码

结论：单线程需按顺序执行，进入死循环后无法继续执行后续代码，但多线程可以让一个线程执行循环，主线程可以执行后续代码

（2）多线程执行顺序的探讨

public class Demo {
    public static void main(String[] args) {
        //实例化MyThread对象
        MyThread102 myThread = new MyThread102();
        //真正去操作系统中申请一个线程并参与cpu调度
        myThread.start();
        while(true){
            System.out.println("main thread...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
//通过继承thread类的方式来创建一个线程
class MyThread102 extends Thread{
    //定义线程要执行的任务
    @Override
    public void run() {
        while(true){
            System.out.println("hello thread...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

结果：

总结：多线程运行并非完全交替执行，在多线程执行时，CPU调度线程并没有固定顺序，是一种抢占式执行，先到先服务

（3）多线程的优势：增加运行速度

对两个变量分别进行十亿次累加，测试单线程和多线程花费时间的不同

//分别对两个变量进行累加
public class Demo_108 {
    public static long count = 10_0000_0000l;
    public static void main(String[] args) {
        serial();
        concurrency();
    }
    public static void serial(){//并发(串行)对两变量累加到一亿
        long begin=System.currentTimeMillis();
        long a = 0l;
        long b = 0l;
        for(long i = 0;i<count;i++){
            a++;
        }
        for(long i = 0;i<count;i++){
            b++;
        }
        long end=System.currentTimeMillis();
        System.out.println("单线程消耗时间="+(end-begin)+"ms");
    }
    public static void concurrency(){//线程（并行）对两变量累加到一亿
        long begin=System.currentTimeMillis();
        Thread thread1 = new Thread(()->{
            long a = 0l;
            for(long i = 0;i<count;i++){
                a++;
            }
        });
        Thread thread2 = new Thread(()->{
            long b = 0l;
            for(long i = 0;i<count;i++){
                b++;
            }
        });
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        long end = System.currentTimeMillis();
        System.out.println("多线程消耗时间="+(end-begin)+"ms");
    }
}

运行结果：