【Java】多线程基础详解

---

线程的相关概念

• 程序：程序是含有指令和数据的文件，也可以说程序是静态代码，被存储在磁盘或者其他的数据存储设备中。
• 进程：进程是程序执行一次的过程。进程是系统运行程序的单位，因此进程是动态的。当程序运行时就会被系统载入内存，并且启动他的工作。对于完全不相关的程序，在同时执行时，不会做数据的交换，而且可以完全独立运行。
• 多任务：多任务是在一个系统中可以同时运行多个进程。每个进程都是独立的任务，每个进程都有自己独立的内存。所谓的同时运行进程，其实是操作系统将资源分配给各个进程以后，每个进程在CPU上交替运行。
• 线程：线程是比进程更小的执行单位。一个进程执行过程可以产生多个线程，形成多条执行路径，提高了运行效率。不同的是，同类的多个线程共享同一块内存，在进行各个线程的切换时开销比进程小很多。
• 多线程：同时执行一个以上的线程，一个线程的执行不必等到另一个线程执行完成在执行。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、创建线程的几种方式

1. 继承Thread类

• Thread 也是实现Runnable接口
• 管理线程的生命周期

2. 实现Runnable接口

• 只有一个run方法

3.实现Callable接口

• 只有一个call方法带有返回值

4. 推荐使用Runnable接口

• extends 只能继承一个类 单继承
• implements 可以实现多个接口 灵活
• 继承Thread的类创建的对象 只能调用一次start 方法启动线程

public class ThreadTest{
    

    public static void main(String[] args){
    
        
         RunTest r1 = new RunTest ();
         Thread t2 = new Thread (r1);
         Thread t3 = new Thread (r1);

         t3.start ();
         t2.start ();

         try {
    
         t3.join ();
         t2.join ();
         } catch (InterruptedException e) {
    
         throw new RuntimeException (e);
         }

         System.out.println (r1.t);


    }
}

class RunTest implements Runnable{
    
    int t;
    Object o1 = new Object ();

    @Override
    public void run(){
    
        // 保证原子性
        synchronized (o1) {
    
            for(int i = 0; i < 10000; i++){
    
                t++;
            }
        }
    }
}

二、线程安全

1. 线程安全问题引入

• 对于一个变量的操作： 使用 赋值 读取 写入 加载 上锁 解锁
• 多个线程同时操作同一个变量：就会因为内存中原子操作不及时等原因导致重复(非同步操作)操作

2.解决线程安全问题

• 保证对于这个共享资源的操作必须是原子操作
• 对资源加锁，操作完成之后释放锁
  • synchronized 关键字
    • 隐式锁 加锁与解锁 不可代码操作的
  • Lock接口下的锁
    • 显式锁 主动的加锁 与 解锁
      • lock
      • unlock
• 在锁块中的代码如果出现了异常中断，卡住
  • 导致此资源不能被释放，一直被当前线程占用
  • 显式锁： 如果出现了异常，可以在finally块中主动的释放资源

3. 线程中的可见性问题：

• 一个线程把资源修改了
• 其他线程无法即时得知

（示例）：对于两个线程 t1 和 t2, 用 t2 线程来控制 t1 线程的关闭；
代码如下：

public class ThreadTest{
    

    public static void main(String[] args){
    

        Thread1 t1= new Thread1 ();
        Thread2 t2= new Thread2 (t1);
        t1.start ();

        try {
    
            Thread.sleep (2000);
        } catch (InterruptedException e) {
    
            throw new RuntimeException (e);
        }
        t2.start ();

    }
}


class Thread1 extends Thread{
    
    boolean flag = true;

    @Override
    public void run(){
    

        System.out.println ("Thread1 启动了...");
        int num=0;
        while(flag){
    
            num++;
        }
        System.out.println ("Thread1 结束了...");
    }
}

class Thread2 extends Thread{
    
    Thread1 t1;

    Thread2(Thread1 t1){
    
        this.t1 = t1;
    }

    @Override
    public void run(){
    

        System.out.println ("Thread2 启动了...");
        t1.flag = false;
        System.out.println (" t1.flag = false; \n Thread2 结束了...");
    }
}

运行结果显示

t2 进程结束了，t1 进程还未结束

解决方法

用volatile关键字 保证线程间通信即时 (不能作为原子操作的标准)
代码如下：

public class ThreadTest{
    

  public static void main(String[] args){
    

    Thread1 t1= new Thread1 ();
    Thread2 t2= new Thread2 (t1);
    t1.start ();

    try {
    
      Thread.sleep (2000);
    } catch (InterruptedException e) {
    
      throw new RuntimeException (e);
    }
    t2.start ();
    
  }
}

class Thread1 extends Thread{
    
  volatile boolean flag = true;

  @Override
  public void run(){
    

    System.out.println ("Thread1 启动了...");
    int num=0;
    while(flag){
    
      num++;
    }
    System.out.println ("Thread1 结束了...");
  }
}

class Thread2 extends Thread{
    
  Thread1 t1;

  Thread2(Thread1 t1){
    
    this.t1 = t1;
  }

  @Override
  public void run(){
    

    System.out.println ("Thread2 启动了...");
    t1.flag = false;
    System.out.println (" t1.flag = false; \n Thread2 结束了...");
  }
}

运行结果显示

t2进程结束后，t1进程也结束了。