多线程&JUC

最新推荐文章于 2024-11-04 22:26:34 发布

落日航班196

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量53

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_60524036/article/details/132723844

版权

线程：线程是操作系统能够进行运行调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

线程的原理：线程是操作系统进行任务调度的最小单位，它是进程内部的执行流程。每个进程可以包含多个线程，这些线程共享进程的地址空间和资源，但具有独立的执行路径和栈空间。线程的原理是通过操作系统的支持，将单个进程划分为多个独立的执行流程，并利用调度算法和同步机制来实现并发执行和数据共享，以提高系统的资源利用率和响应性能。

进程：进程是程序的基本执行实体。

并发：在同一时刻，有多个指令在单个CPU上交替执行。

并行：在同一时刻，有多个指令在多个CPU上同时执行。

符合目前的CPU执行：四核八线程CPU
八线程的CPU执行5000个线程-切片执行
CPU执行速度快，把一个线程都执行一会儿，切换到下一个线程执行一会儿，再切回来
绝对的同时只能同时执行8个

Java实现多线程：任何一个Java程序都是多线程，Java程序运行在JVM上，Main线程 + JVM中的其他线程 GC

多线程的实现方式：

继承Thread类的方式进行实现

public class ThreadDemo{
/*
*多线程的第一中启动方式:
* 1.自己定义一个类继承Thread
* 2.重写run方法
* 3.创建子类的对象，并启动线程
* */

    public static void main(String[] args) {
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread();
        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();

    }
}

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

实现Runnable接口的方式实现

package com.itheima.a02threadcase;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
         * 多线程
         * 1.自己定义一个类来实现Runnable接口
         * 2.重写里面的run方法
         * 3.创建自己的对象
         * 4.创建一个Thread类的对象，并开启线程
         * */

        //创建MyRun的对象
        //表示多线程要执行的任务
        MyRun mr = new MyRun();

        //创建线程对象
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);

        //给线程设置名字
        t1.setName("线程1");
        t2.setName("线程2");

        //开启线程
        t1.start();
        t2.start();
    }
}

class MyRun implements Runnable{
    @Override
    public void run() {
        //书写线程要执行的代码
        for (int i = 0; i < 100; i++) {
            Thread t = Thread.currentThread();
            System.out.println(t.getName() + "HelloWorld");
        }
    }
}

利用Callable接口和Future接口方式实现

package com.itheima.a03threadcase;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class ThreadDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /*
        * 多线程第三种实现方式:
        *   特点： 可以获得多线程运行的结果
        *   1. 创建一个类MyCallable实现Callable接口
        *   2. 重写call (是有返回值的， 表示多线程运行的结果)
        *   3. 创建MyCallable的对象(表示多线程要执行的任务)
        *   4. 创建FutureTask的对象(作用管理多线程运行的结果)
        *   5. 创建Thread类的对象， 并启动(表示线程)
        * */
        //创建MyCallable的对象（表示多线程要执行的任务）
        MyCallable mc = new MyCallable();
        //创建FutureTask的对象(作用管理多线程运行的结果)
        FutureTask<Integer> ft = new FutureTask<>(mc);
        //创建线程的对象
        Thread t1 = new Thread(ft);
        //启动线程
        t1.start();

        //获取多线程运行的结果
        Integer result = ft.get();
        System.out.println(result);
    }
}

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        //求1~100之间的和
        int sum = 0;
        for (int i = 0; i <= 100 ; i++) {
            sum += i;
        }
        return sum;
    }
}

常见的成员方法
- String getName() 返回线程的名称
- void setName(String name) 设置线程的名字（构造方法也可以设置名字）
- static Thread currentThread() 获取当前线程的对象
- static void sleep(long time) 让线程休眠指定的时间，单位为毫秒
- setPriority(int newPriority) 设置线程的优先级
- final int getPriority() 获取线程的优先级
- final void setDaemon(boolean on) 设置守护线程
- public static void yield() 出让线程/礼让线程

public static void join() 插入线程/插队线程

public class ThreadDemo {
    public static void main(String[] args) throws InterruptedException {
        /*
                String getName()               返回线程的名称

                void setName(String name)       设置线程的名字（构造方法也可以设置名字）
                细节：
                    1.如果我们没有给线程设置名字，线程也是有默认的名字的
                        格式：Thread-X(X序号，从0开始的)
                    2.如果我们要给线程设置名字，可以用set方法进行设置，也可以构造方法设置

                static Thread currentThread()   获取当前线程的对象
                    细节：
                        当JVM虚拟机启动后，会自动启动多条线程
                        其中有一条就叫做 mian线程
                        他的作用就是去调用main方法，并执行里面的代码
                        在以前， 我们写的所有的代码，其实都是运行在main线程当中的

                static void sleep(long time)    让线程休眠指定的时间， 单位为毫秒
                细节：
                    1.那条进程执行到这个方法， 那么哪条进程就会在这里停留对应的时间
                    2.方法的参数： 就表示睡眠的时间，单位毫秒
                        1秒=1000毫秒
                    3.当时间到了之后，线程会自动的醒来，继续执行下面的其他代码
        * */

/*        //1.创建线程对象
        Mythread t1 = new Mythread("飞机");
        Mythread t2 = new Mythread("坦克");


//        t1.setName("线程1");
//        t2.setName("线程2");

        //2.开启线程
        t1.start();
        t2.start();*/

        /*Thread t = Thread.currentThread();
        String name = t.getName();
        System.out.println(name);*/

        System.out.println("11111111");
        Thread.sleep(5000);
        System.out.println("22222222");

    }
}

class Mythread extends Thread{
    public Mythread() {
    }

    public Mythread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + "@" + i);
        }
    }
}

package com.itheima.a05threadcase;

public class ThreadDemo {
    public static void main(String[] args) {
        /*
         *   setPriority(int newPriority)
         *   final int getPriority
         * */

        //创建线程执行的参数对象
        MyRunnerable mr = new MyRunnerable();
        //创建线程对象
        Thread t1 = new Thread(mr,"飞机");
        Thread t2 = new Thread(mr,"坦克");

        t1.setPriority(1);
        t2.setPriority(10);

        t1.start();
        t2.start();

    }
}

class MyRunnerable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "-----" + i);
        }
    }
}