首页 > 编程学习 > Java基础巩固(二)——多线程

Java基础巩固(二)——多线程

发布时间:2022/9/22 22:48:40

Java基础巩固(二)——多线程

1.基本概念

  • 程序是指令和数据的有序集合,其本身没有任何运行的含义,是一个静态的概念。
  • 进程是执行程序的一次执行过程,它是一个动态的概念。是系统资源分配的单位。
  • 一个进程可以包含若干个线程,线程是cpu调度和执行的单位。
  • 进程是资源分配的最小单位,线程是程序执行的最小单位
  • 在程序运行时,即使没有自己创建线程,后台也会有多个线程,如主线程、gc线程;
  • 在一个进程中,如果开辟了多个线程,线程的运行由调度器安排调度,调度器是与操作系统紧密相关的,先后顺序是不能认为干预的;

2.线程的创建方式

  • 通过继承Thread类来创建
//创建线程方式一:继承Thread类,重写run()方法
public class ThreadPractice extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("正在运行线程一__" + i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            System.out.println("正在运行       主线程__" + i);
        }
/* xx.start()和xx.run()是不同的,前者是创建进程,后者是运行任务,前者线程与主线程同时进行,后者根据主线程中的顺序先后进行 */
        ThreadPractice thread1 = new ThreadPractice();
        thread1.start();        
//      thread1.run();
    }
}

  • 通过实现Runnable接口来创建(可以实现多个线程对同一个对象的调用,避免了单继承的局限性)
//创建线程方式二:实现Runnable接口
public class ThreadPractice3 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("正在运行线程一__" + i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 200; i++) {
            System.out.println("正在运行       主线程__" + i);
        }
        ThreadPractice3 thread1 = new ThreadPractice3();
        new Thread(thread1).start();
    }
}
  • 通过实现Callable接口来创建(优点是可以定义返回值类型,抛出异常)
public class ThreadPractice4 implements Callable<Boolean> {

    private String name;
    private int age;

    public ThreadPractice4(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public Boolean call() {
        test test1 = new test();
        test1.Show(name, age);
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadPractice4 thread1 = new ThreadPractice4("小白",15);
        ThreadPractice4 thread2 = new ThreadPractice4("小黑",20);
        ThreadPractice4 thread3 = new ThreadPractice4("小红",30);

        //创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(3);
        //提交执行
        Future<Boolean> r1 = service.submit(thread1);
        Future<Boolean> r2 = service.submit(thread2);
        Future<Boolean> r3 = service.submit(thread3);
        //获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        service.shutdownNow();
    }
}


class test {
    public void Show(String name, int age) {
        System.out.println("这个人叫" + name + ",今年" + age + "岁。");
    }
}

此方法总结为以下几步:

  1. 实现Callable接口,需要返回值类型,例如上诉例子的Boolean
  2. 重写call方法,需要抛出异常
  3. 创建目标对象
  4. 创建执行服务:ExecutorService service = Executors.newFixedThreadPool(1);
  5. 提交执行:Future r1= service.submit(t1);
  6. 获取结果:boolean rs1 = r1.get();
  7. 关闭服务:service.shutdownNow();

3.lambda表达式(包括五种类的演示)

interface Ilove{
    void love(int a);
}

//第一种,正常类
class Love implements Ilove {
    @Override
    public void love(int a) {
        System.out.println("i love  ->" + a);
    }
}


public class TestLambda {

    //第二种,静态内部类
    static class Love2 implements Ilove {
        @Override
        public void love(int a) {
            System.out.println("i love2 ->" + a);
        }
    }

    public static void main(String[] args) {
        Ilove ilove = new Love();
        ilove.love(2);

        Ilove ilove2 = new Love2();
        ilove2.love(2);

        //第三种,局部内部类
        class Love3 implements Ilove {
            @Override
            public void love(int a) {
                System.out.println("i love3 ->" + a);
            }
        }

        Ilove ilove3 = new Love3();
        ilove3.love(2);

        //第四种,匿名内部类
        Ilove ilove4 = new Ilove() {
            @Override
            public void love(int a) {
                System.out.println("i love4 ->" + a);
            }
        };
        ilove4.love(2);

        //第五种,lambda表达式
        Ilove ilove5 = (int a) -> {
            System.out.println("i love5 ->" + a);
        };
        ilove5.love(2);

    }
}

4.线程状态

创建、就绪、运行、阻塞、死亡

线程操作:

  • 线程礼让,Thread.yield()
  • 线程插队,Thread.join()
  • 线程等待,Thread.sleep()
  • 线程优先级,Thread.setPriority()、getPriority()
  • 线程状态,Thread.getState()
  • 守护线程,Thread.setDaemon()

5.线程同步

synchronized

6.线程协作

Copyright © 2010-2022 mfbz.cn 版权所有 |关于我们| 联系方式|豫ICP备15888888号