Java-线程概述、多线程创建、多线程常用API

个人简介

• 大家好，我是翰慧腾。一名正在努力学JAVA的大一小白，本文章为初学的笔记，希望各位多多指教。💙
• 欢迎点赞+收藏+留言💜
• 一事无成也代表万事皆有可能🧡

一、线程

概述：线程是一个程序内部的一条执行路径；就比如说之前的启动程序执行后，main方法的执行其实就是一条单独的执行路径。如果程序中只有一条执行路径，那么这个程序就是单线程的程序。

多线程:多线程是指从软硬件上实现多条执行流程的技术。

多线程的学习：

二、多线程的创建

1.继承Thread类：

/**
 * @author hanhan
 * date 2022/4/16 22:56
 * 努力已经来不及了，你得拼命
 */
public class ThreadDemo_ {
    public static void main(String[] args) {
        Thread my = new MyThread();
        my.start();//启动线程
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程"+i);
        }
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("子线程"+i);
        }
    }
}

优点：代码简单

缺点：已继承Thread类，无法继承其他类，不利于扩展。

2.实现Runnable接口

/**
 * @author hanhan
 * date 2022/4/16 23:23
 * 努力已经来不及了，你得拼命
 */
public class ThreadDemo_01 {
    public static void main(String[] args) {
        Runnable my = new MyRunnable();
        Thread t = new Thread(my);
        t.start();//启动线程
        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出"+i);
        }
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println("子线程执行输出"+i);
        }
    }
}

 优点：线程任务类只是实现接口，可以继续继承和实现接口，扩展性强。

缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

实现Runnable接口（匿名内部类形式）

/**
 * @author hanhan
 * date 2022/4/17 8:15
 * 努力已经来不及了，你得拼命
 */
public class ThreadDemo_01other {
    public static void main(String[] args) {
        Runnable r=new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 5; i++) {
                    System.out.println("子线程执行输出"+i);
                }
            }
        };
        Thread t = new Thread(r);
        t.start();
        for (int i = 0; i < 4; i++) {
            System.out.println("主线程执行输出"+i);

        }
    }
}

 3.JDK5.0新增:实现Callable接口

前两种线程创建方式都存在一个问题：他们重写的run方法均不能直接返回结果，不适合需要返回线程执行结果的业务场景。

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

/**
 * @author hanhan
 * date 2022/4/17 8:39
 * 努力已经来不及了，你得拼命
 */
public class ThreadDemo_02 {
    public static void main(String[] args) {
        //创建Callable对象，
        Callable<String> call = new MyCallable(10);
        //FutureTask对象的作用1：是Runnable对象（实现了Runnable接口），可以直接交给Thread
        //FutureTask对象的作用2:可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f = new FutureTask<>(call);
        Thread t = new Thread(f);//交给线程处理
        t.start();
        try {
            String s=f.get();//通过get方法可以获得call方法执行的返回结果
            System.out.println(s);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class MyCallable implements Callable<String>{
    private int n;
    public MyCallable(int n){
        this.n=n;
    }
    @Override
    public String call() throws Exception {
        int sum=0;
        for (int i = 0; i < n; i++) {
            sum+=i;
        }
        return "子线程执行的结果是："+sum;
    }
}

 优点：线程任务类只是实现接口，可以继承其他类和实现接口，扩展性强。可以在线程执行完毕后去获取线程执行的结果。

缺点：编程相对较烦。

三种线程创建方式对比；

 三、线程（Thread）常用方法

Thread设置和获取线程名称

 

注意：该方法是Thread类的静态方法，可以直接使用Thread类调用 ；这个方法是在哪个线程执行中调用的，就会得到哪个线程对象。

/**
 * @author hanhan
 * date 2022/4/17 10:52
 * 努力已经来不及了，你得拼命
 */
public class ThreadDemo_03 {
    public static void main(String[] args) {
        Thread t1 = new MyThreadDemo_();
        t1.setName("线程1");
        t1.start();
        Thread t2 = new MyThreadDemo_();
        t2.setName("线程2");
        t2.start();
        //改变main函数的线程名称
        Thread t = Thread.currentThread();
        t.setName("最牛逼线程");
        for(int i=0;i<7;i++){
            System.out.println(Thread.currentThread().getName()+i);
        }

    }
}
class MyThreadDemo_ extends Thread{
    @Override
    public void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}

 

例题：有三种原因可以导致线程不能运行：等待、阻塞、睡眠

Java语言中提供了一个垃圾收集线程，自动回收动态分配的内存

当run方法终止时，能使线程进入死亡状态

用setPrority方法可以改变线程的优先级

join函数：等待线程终止

yield函数可以理解为“让步”，它的作用是：暂停当前正在执行的线程对象，并执行其他线程