java多线程基础（实现多线程的方式，获取与修改线程名的方法）

1、多线程的并发和并行
并发：在同一时刻，有多个指令在***单个CPU***上***交替***执行；
并行：在同一时刻，有多个指令在多个CPU上同时执行；

2、进程与线程的区别
进程：操作系统中正在执行的一个***应用程序***
线程：应用程序中做的事情，比如：360软件中的杀毒、扫描木马、清理垃圾

3、多线程的实现方案***（3种）***
3.1 继承Thread类
定义一个MyThread类继承Thread类；
在Thread中重写run方法（重写run，是因为run方法是用来封装被线程执行的代码）；
创建Mythread类的对象；
启动线程。

3.2 实现Runnable接口的步骤
定义一个MyRunnable实现Runnable接口；
在Thread中重写run方法；
创建MyRunnable类的对象；
创建Thread类的对象，把MyRunnable类的对象作为构造方法的参数；
启动线程。

3.3 Callable和Future
定义一个MyCallable实现Callable接口；
在MyCallable中重写call方法；
创建MyCallable类的对象；
创建Future类的实现类FutureTask，把MyCallable类的对象作为构造方法的参数；
创建Thread类的对象，把FutureTask类的对象作为构造方法的参数；
启动线程。

4、***3种线程实现方式***的对比
4.1 实现Runnable接口、Callable接口：优点是 扩展性强，实现该接口同时能继承其他类；
缺点是 编程相对复杂，不能直接用Thread中的方法

4.2 继承Thread类、：优点是 编程相对简单，能直接用Thread中的方法
缺点是 扩展性差，不能继承其他类

5、run方法与start方法的区别：
run（）：封装被线程执行的代码，直接调用，相当于普通方法的调用，并未开启线程
start（）：启动线程，然后由JVM调用此线程的方法

6、具体实例
6.1 继承Thread类

public class Mythread01 extends Thread {
    @Override
    public void run() {
//        代码是在线程开启后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了"+i);
        }
    }
}


public class MyThreadDemo01 {
    public static void main(String[] args) {
//        创建一个线程对象
        Mythread01 t1 = new Mythread01();
//        创建一个线程对象
        Mythread01 t2 = new Mythread01();
        
//        run相当于普通方法，不能开启线程，线程1执行完，线程2才执行
 //       t1.run();
  //     t2.run();

//        开启一个线程
     t1.start();
//       开启第2个线程
    t2.start();
    }
}

6.2 实现Runnable接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
//        代码是在线程开启后执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println("第二种方式实现多线程"+i);
        }
    }
}

public class MyRunnableDemo {
    public static void main(String[] args) {
        MyRunnable mr1 = new MyRunnable();
        Thread t1 = new Thread(mr1);
        t1.start();

        MyRunnable mr2 = new MyRunnable();
        Thread t2 = new Thread(mr2);
        t2.start();
    }
}

6.3 Callable和Future

import java.util.concurrent.Callable;

public class MyCallable implements Callable {

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("表白"+i);
        }
        return "同意";
    }
}



import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallableDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//    线程开启后要执行里面的call方法
        MyCallable mr1 = new MyCallable();

//        可以获取线程执行完毕后的结果，也可作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(mr1);

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

//        若线程还未执行完，那么get方法会在此死等
//        String s = ft.get();

//        开启线程
          t1.start();
        
//        获得线程运行后的结果
        String s = ft.get();
        System.out.println(s);
    }
}

7、获取线程的名称的方法（2种）
7.1 使用Thread 类中的方法getName()
String getName（）返回该线程的名称；
7.2 可以获取到当前正在执行的线程，使用线程中的方法getName()获取线程名称
static Thread currentThread（）返回对当前正在执行的线程对象的引用

//定义一个Thread类的子类
public class Mythread02 extends Thread {
//    重写Thread中的run方法，设置线程任务
    @Override
    public void run() {

/*
//        第一种：使用Thread 类中的方法getName()获取线程名称
        String name = getName();
        System.out.println(name);
//        第二种：获取到当前正在执行的线程，使用线程中的方法getName()获取线程名称
        Thread thread = Thread.currentThread();
        System.out.println(thread);
        String name1 = thread.getName();
        System.out.println(name1);
*/

//       链式编程（第二种的变形）
        System.out.println( Thread.currentThread().getName());
    }



/*
线程名称 main
新线程：Thread-0，Thread-1，Thread-2
 */
public class MyThreadDemo02 {
    public static void main(String[] args) {
//    创建Thread类的子类对象
        Mythread02 t1 = new Mythread02();   //Thread-0
//      调用start方法，开启线程，执行run方法
        t1.start();

        new Mythread02().start(); //Thread-1
        new Mythread02().start(); //Thread-2

        //       链式编程,当前线程名main
        System.out.println( Thread.currentThread().getName());
    }
}

7、设置线程的名称（了解）
7.1 使用Thread 类中的方法setName()
void setName（String name）改变线程的名称，使之与参数name相同
7.2 创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参构造方法，把线程名称传递给父类，
让父类（Thread）给子线程起一个名字
Thread （String name）分配新的Thread对象

public class Mythread03 extends Thread {
/*
//第一种 ，7.1使用Thread 类中的方法setName()
    @Override
    public void run() {
        System.out.println( Thread.currentThread().getName()); //  获取线程的名称
    }
*/

//第二种， 7.2 
    public Mythread03() {
    }
    public Mythread03(String name) {
        super(name); //把线程名称传递给父类，让父类Thread给子线程起个名字
    }

    @Override
    public void run() {
        System.out.println( Thread.currentThread().getName());
    }
}





public class SetThreadNameDemo03 {
    public SetThreadNameDemo03() {
    }
    public static void main(String[] args) {
//   开启第一个线程
        Mythread03 t1 = new Mythread03();
        t1.setName("小花");
        t1.start();
//        开启第二个线程
        new Thread("柯基").start();
    }
}

本文地址：https://blog.csdn.net/qq_45476949/article/details/114274126