【多线程】Java多线程基础

 

一、基础概念

（一）并行和并发

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

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

并行示意图：完成几项任务，某一时刻同时执行 。三个厨师同时做饭

并发示例图：完成几项任务，某一时刻只有一个线程在做事情，CPU在这几个任务间来回切换。一个厨师在三个锅来回移动做饭。

（二）进程和线程

1、概念

     进程：一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的exe就是一个进程。

    线程：进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

2、区别

     进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位

3、资源开销

     每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。

4、包含关系

      如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；线程是进程的一部分，所以线程也被称为轻权进程或者轻量级进程 。

5、内存分配

       同一进程的线程共享本进程的地址空间和资源，而进程之间的地址空间和资源是相互独立的

6、相互影响

      一个进程崩溃后，在保护模式下不会对其他进程产生影响，但是一个线程崩溃整个进程都死掉。所以多进程要比多线程健壮。

 7、执行过程

        每个独立的进程有程序运行的入口、顺序执行序列和程序出口。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制，两者均可并发执行。

二、多线程的实现方式

（一）继承Thread类

步骤：

1. 定义一个Thread的子类

2. 在子类中重写run（）方法 //run（）方法用来封装被线程执行的代码

3. 创建该类的对象

4. 调用该类对象的start方法启动线程 //start（）方法用来启动一个线程

public class MyThread extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了"+i);
        }
    }
}

测试类：

public class Demo {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        MyThread myThread2 = new MyThread();
        myThread.start();
        myThread2.start();
    }
}

（二）实现Runnable接口

步骤：

1. 定义一个类实现Runnable接口

2. 在实现类中重写run（）方法 //run（）方法用来封装被线程执行的代码

3. 创建实现类的对象

4. 创建Thread类的对象，把第三步创建好的实现类对象作为构造方法的参数传入

5. 调用Thread类对象的start（）方法启动线程

   public class MyRunnable implements Runnable{
       @Override
       public void run() {
           for (int i = 0; i < 100; i++) {
               System.out.println("线程开启了"+i);
           }
       }
   }

   测试类：

public class Demo {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        MyRunnable myRunnable2 = new MyRunnable();

        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable2);
        thread1.start();
        thread2.start();
    }
}

（三）Callable和Future

步骤：

1. 定义一个实现Callable接口的类（例如MyCallable）

2. 在实现类MyCallable中重写call（）方法

3. 创建MyCallable类的对象

4. 创建中间件对象FutureTask，并把MyCallable类的对象作为参数参数

5. 创建线程类，把FutureTask类的对象作为参数传入

6. 调用Thread类对象的start（）方法启动线程

7. 使用FutureTask类的对象获取返回结果

public class MyCallable implements Callable<String> {
    
    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("跟女孩儿表白"+i+"次");
        }
        return "答应";
    }
}

public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        FutureTask<String> futureTask = new FutureTask<String>(myCallable);
        Thread thread = new Thread(futureTask);
        thread.start();
        String s = futureTask.get();
        System.out.println();
    }
}

（四）线程实现方式的对比

名称	优点	缺点
实现Runnable、Callable接口	扩展性强，实现该接口的同时可以继承其他的类	编程相对复杂，不能直接使用Thread类中的方法
继承Thread	编程简单，可以直接使用Thread类的方法	扩展性差，不能再继承其他类

三、Thread类中的方法

（一）获取和设置线程的名称

• public final String getName() 获取线程的名称

• public final synchronized void setName(String name) 设置线程的名称

（二）获取当前的线程对象

public static native Thread currentThread()：返回当前的线程对象

public class Demo {
    public static void main(String[] args){
        String name = Thread.currentThread().getName();
        System.out.println(name);
    }
}

（三）线程休眠

public static native void sleep(long millis)：让线程休眠指定的时间，单位是毫秒

例子一：主线程休眠

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        System.out.println("睡觉前");
        Thread.sleep(5000);
        System.out.println("睡醒了");
    }
}

例子二：自定义线程的休眠

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"--"+i);
        }
    }
}

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);
        thread1.start();
        thread2.start();
    }
}

（四）设定线程的优先级

1、线程的调度

多线程的并发运行 ：

计算机中的CPU，在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行代码，各个线程轮流获得CPU的使用权，分别执行各自的任务。

线程的两种调度模型 ：

• 分时调度模型：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间片。

• 抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级线程获取CPU时间片相对多一点

2、线程优先级的设定

public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"---"+i+"次");
        }
        return "线程执行完毕了";
    }
}

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        MyCallable myCallable1 = new MyCallable();
        FutureTask<String> futureTask1 = new FutureTask<>(myCallable1);
        MyCallable myCallable2 = new MyCallable();
        FutureTask<String> futureTask2 = new FutureTask<>(myCallable2);
        Thread thread1 = new Thread(futureTask1);
        Thread thread2 = new Thread(futureTask2);
        thread1.setName("飞机");
        System.out.println(thread1.getPriority());
        thread1.setPriority(10);
        thread2.setName("坦克");
        System.out.println(thread2.getPriority());
        thread2.setPriority(1);
        thread1.start();
        thread2.start();
    }
}

（五）守护线程/后台线程

在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程) ，用个比较通俗的比喻，任何一个守护线程都是整个JVM中所有非守护线程的保姆

只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。Daemon的作用是为其他线程的运行提供便利服务，守护线程最典型的应用就是 GC (垃圾回收器)，它就是一个很称职的守护者。

User和Daemon两者几乎没有区别，唯一的不同之处就在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也就退出了。 因为没有了被守护者，Daemon也就没有工作可做了，也就没有继续运行程序的必要了。

值得一提的是，守护线程并非只有虚拟机内部提供，用户在编写程序时也可以自己设置守护线程。下面的方法就是用来设置守护线程的。

Thread daemonTread = new Thread();
// 设定 daemonThread 为 守护线程，default false(非守护线程)
daemonThread.setDaemon(true);
// 验证当前线程是否为守护线程，返回 true 则为守护线程
 daemonThread.isDaemon();

注意：

1. thread.setDaemon(true)必须在thread.start()之前设置，否则会跑出一个IllegalThreadStateException异常。你不能把正在运行的常规线程设置为守护线程。

2. 在Daemon线程中产生的新线程也是Daemon的

3. 不要认为所有的应用都可以分配给Daemon来进行服务，比如读写操作或者计算逻辑，因为你不可能知道在所有的User完成之前，Daemon是否已经完成了预期的服务任务。一旦User退出了，可能大量数据还没有来得及读入或写出，计算任务也可能多次运行结果不一样。这对程序是毁灭性的。造成这个结果理由已经说过了：一旦所有User Thread离开了，虚拟机也就退出运行了。例如如下代码：

 

//完成文件输出的守护线程任务
import java.io.*;   
  
class TestRunnable implements Runnable{   
    public void run(){   
               try{   
                  Thread.sleep(1000);//守护线程阻塞1秒后运行   
                  File f=new File("daemon.txt");   
                  FileOutputStream os=new FileOutputStream(f,true);   
                  os.write("daemon".getBytes());   
           }   
               catch(IOException e1){   
          e1.printStackTrace();   
               }   
               catch(InterruptedException e2){   
                  e2.printStackTrace();   
           }   
    }   
}   
public class TestDemo2{   
    public static void main(String[] args) throws InterruptedException   
    {   
        Runnable tr=new TestRunnable();   
        Thread thread=new Thread(tr);   
                thread.setDaemon(true); //设置守护线程   
        thread.start(); //开始执行分进程   
    }   
}   
//运行结果：文件daemon.txt中没有"daemon"字符串。

在主线程结束后，守护线程仍然没有完成任务，虚拟机就退出了。

三、线程的状态

Java线程的六种状态：

• 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

• 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

• 阻塞(BLOCKED)：表示线程阻塞于锁。

• 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

• 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。

• 终止(TERMINATED)：表示该线程已经执行完毕。