java 基础教程之多线程详解及简单实例

2024-12-02 02:08:31

java 多线程详解

在这篇文章里，我们关注多线程。多线程是一个复杂的话题，包含了很多内容，这篇文章主要关注线程的基本属性、如何创建线程、线程的状态切换以及线程通信。

　　线程是操作系统运行的基本单位，它被封装在进程中，一个进程可以包含多个线程。即使我们不手动创造线程，进程也会有一个默认的线程在运行。

　　对于JVM来说，当我们编写一个单线程的程序去运行时，JVM中也是有至少两个线程在运行，一个是我们创建的程序，一个是垃圾回收。

　　线程基本信息

　　我们可以通过Thread.currentThread()方法获取当前线程的一些信息，并对其进行修改。

　　我们来看以下代码：

查看并修改当前线程的属性
String name = Thread.currentThread().getName();
    int priority = Thread.currentThread().getPriority();
    String groupName = Thread.currentThread().getThreadGroup().getName();
    boolean isDaemon = Thread.currentThread().isDaemon();
    System.out.println("Thread Name:" + name);
    System.out.println("Priority:" + priority);
    System.out.println("Group Name:" + groupName);
    System.out.println("IsDaemon:" + isDaemon);

    Thread.currentThread().setName("Test");
    Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
    name = Thread.currentThread().getName();
    priority = Thread.currentThread().getPriority();
    groupName = Thread.currentThread().getThreadGroup().getName();
    isDaemon = Thread.currentThread().isDaemon();
    System.out.println("Thread Name:" + name);
    System.out.println("Priority:" + priority);

　　其中列出的属性说明如下：

GroupName，每个线程都会默认在一个线程组里，我们也可以显式的创建线程组，一个线程组中也可以包含子线程组，这样线程和线程组，就构成了一个树状结构。
Name，每个线程都会有一个名字，如果不显式指定，那么名字的规则是“Thread-xxx”。
Priority，每个线程都会有自己的优先级，JVM对优先级的处理方式是“抢占式”的。当JVM发现优先级高的线程时，马上运行该线程；对于多个优先级相等的线程，JVM对其进行轮询处理。Java的线程优先级从1到10，默认是5，Thread类定义了2个常量：MIN_PRIORITY和MAX_PRIORITY来表示最高和最低优先级。

我们可以看下面的代码，它定义了两个不同优先级的线程：

线程优先级示例
public static void priorityTest()
{
  Thread thread1 = new Thread("low")
  {
    public void run()
    {
      for (int i = 0; i < 5; i++)
      {
        System.out.println("Thread 1 is running.");
      }
    }
  };

  Thread thread2 = new Thread("high")
  {
    public void run()
    {
      for (int i = 0; i < 5; i++)
      {
        System.out.println("Thread 2 is running.");
      }
    }
  };

  thread1.setPriority(Thread.MIN_PRIORITY);
  thread2.setPriority(Thread.MAX_PRIORITY);
  thread1.start();
  thread2.start();
}

从运行结果可以看出，是高优先级线程运行完成后，低优先级线程才运行。

isDaemon，这个属性用来控制父子线程的关系，如果设置为true，当父线程结束后，其下所有子线程也结束，反之，子线程的生命周期不受父线程影响。

我们来看下面的例子：

IsDaemon 示例
public static void daemonTest()
{
  Thread thread1 = new Thread("daemon")
  {
    public void run()
    {
      Thread subThread = new Thread("sub")
      {
        public void run()
        {
          for(int i = 0; i < 100; i++)
          {
            System.out.println("Sub Thread Running " + i);
          }
        }
      };
      subThread.setDaemon(true);
      subThread.start();
      System.out.println("Main Thread end.");
    }
  };

  thread1.start();
}

上面代码的运行结果，在和删除subThread.setDaemon(true);后对比，可以发现后者运行过程中子线程会完成执行后再结束，而前者中，子线程很快就结束了。

　　如何创建线程

　　上面的内容，都是演示默认线程中的一些信息，那么应该如何创建线程呢？在Java中，我们有3种方式可以用来创建线程。

　　Java中的线程要么继承Thread类，要么实现Runnable接口，我们一一道来。

　　使用内部类来创建线程

　　我们可以使用内部类的方式来创建线程，过程是声明一个Thread类型的变量，并重写run方法。示例代码如下：

使用内部类创建线程
public static void createThreadByNestClass()
{
  Thread thread = new Thread()
  {
    public void run()
    {
      for (int i =0; i < 5; i++)
      {
        System.out.println("Thread " + Thread.currentThread().getName() + " is running.");
      }
      System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");
    }
  };
  thread.start();
}

　　继承Thread以创建线程

　　我们可以从Thread中派生一个类，重写其run方法，这种方式和上面相似。示例代码如下：

派生Thread类以创建线程
class MyThread extends Thread
{
  public void run()
  {
    for (int i =0; i < 5; i++)
    {
      System.out.println("Thread " + Thread.currentThread().getName() + " is running.");
    }
    System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");
  }
}

public static void createThreadBySubClass()
{
  MyThread thread = new MyThread();
  thread.start();
}

　　实现Runnable接口以创建线程

　　我们可以定义一个类，使其实现Runnable接口，然后将该类的实例作为构建Thread变量构造函数的参数。示例代码如下：

实现Runnable接口以创建线程
class MyRunnable implements Runnable
{
  public void run()
  {
    for (int i =0; i < 5; i++)
    {
      System.out.println("Thread " + Thread.currentThread().getName() + " is running.");
    }
    System.out.println("Thread " + Thread.currentThread().getName() + " is finished.");
  }
}

public static void createThreadByRunnable()
{
  MyRunnable runnable = new MyRunnable();
  Thread thread = new Thread(runnable);
  thread.start();
}

　　上述3种方式都可以创建线程，而且从示例代码上看，线程执行的功能是一样的，那么这三种创建方式有什么不同呢？

　　这涉及到Java中多线程的运行模式，对于Java来说，多线程在运行时，有“多对象多线程”和“单对象多线程”的区别：

多对象多线程，程序在运行过程中创建多个线程对象，每个对象上运行一个线程。
单对象多线程，程序在运行过程中创建一个线程对象，在其上运行多个线程。

　　显然，从线程同步和调度的角度来看，多对象多线程要简单一些。上述3种线程创建方式，前两种都属于“多对象多线程”，第三种既可以使用“多对象多线程”，也可以使用“单对象单线程”。

　　我们来看下面的示例代码，里面会用到Object.notify方法，这个方法会唤醒对象上的一个线程；而Object.notifyAll方法，则会唤醒对象上的所有线程。

notify示例
public class NotifySample {

  public static void main(String[] args) throws InterruptedException
  {
    notifyTest();
    notifyTest2();
    notifyTest3();
  }

  private static void notifyTest() throws InterruptedException
  {
    MyThread[] arrThreads = new MyThread[3];
    for (int i = 0; i < arrThreads.length; i++)
    {
      arrThreads[i] = new MyThread();
      arrThreads[i].id = i;
      arrThreads[i].setDaemon(true);
      arrThreads[i].start();
    }
    Thread.sleep(500);
    for (int i = 0; i < arrThreads.length; i++)
    {
      synchronized(arrThreads[i])
      {
        arrThreads[i].notify();
      }
    }
  }

  private static void notifyTest2() throws InterruptedException
  {
    MyRunner[] arrMyRunners = new MyRunner[3];
    Thread[] arrThreads = new Thread[3];
    for (int i = 0; i < arrThreads.length; i++)
    {
      arrMyRunners[i] = new MyRunner();
      arrMyRunners[i].id = i;
      arrThreads[i] = new Thread(arrMyRunners[i]);
      arrThreads[i].setDaemon(true);
      arrThreads[i].start();
    }
    Thread.sleep(500);
    for (int i = 0; i < arrMyRunners.length; i++)
    {
      synchronized(arrMyRunners[i])
      {
        arrMyRunners[i].notify();
      }
    }
  }

  private static void notifyTest3() throws InterruptedException
  {
    MyRunner runner = new MyRunner();
    Thread[] arrThreads = new Thread[3];
    for (int i = 0; i < arrThreads.length; i++)
    {
      arrThreads[i] = new Thread(runner);
      arrThreads[i].setDaemon(true);
      arrThreads[i].start();
    }
    Thread.sleep(500);

    synchronized(runner)
    {
      runner.notifyAll();
    }
  }
}

class MyThread extends Thread
{
  public int id = 0;
  public void run()
  {
    System.out.println("第" + id + "个线程准备休眠5分钟。");
    try
    {
      synchronized(this)
      {
        this.wait(5*60*1000);
      }
    }
    catch(InterruptedException ex)
    {
      ex.printStackTrace();
    }
    System.out.println("第" + id + "个线程被唤醒。");
  }
}

class MyRunner implements Runnable
{
  public int id = 0;
  public void run()
  {
    System.out.println("第" + id + "个线程准备休眠5分钟。");
    try
    {
      synchronized(this)
      {
        this.wait(5*60*1000);
      }
    }
    catch(InterruptedException ex)
    {
      ex.printStackTrace();
    }
    System.out.println("第" + id + "个线程被唤醒。");
  }

}

　　示例代码中，notifyTest()和notifyTest2()是“多对象多线程”，尽管notifyTest2()中的线程实现了Runnable接口，但是它里面定义Thread数组时，每个元素都使用了一个新的Runnable实例。notifyTest3()属于“单对象多线程”，因为我们只定义了一个Runnable实例，所有的线程都会使用这个实例。

　　notifyAll方法适用于“单对象多线程”的情景，因为notify方法只会随机唤醒对象上的一个线程。

　　线程的状态切换

　　对于线程来讲，从我们创建它一直到线程运行结束，在这个过程中，线程的状态可能是这样的：

创建：已经有Thread实例了，但是CPU还有为其分配资源和时间片。
就绪：线程已经获得了运行所需的所有资源，只等CPU进行时间调度。
运行：线程位于当前CPU时间片中，正在执行相关逻辑。
休眠：一般是调用Thread.sleep后的状态，这时线程依然持有运行所需的各种资源，但是不会被CPU调度。
挂起：一般是调用Thread.suspend后的状态，和休眠类似，CPU不会调度该线程，不同的是，这种状态下，线程会释放所有资源。
死亡：线程运行结束或者调用了Thread.stop方法。

　　下面我们来演示如何进行线程状态切换，首先我们会用到下面方法：

Thread()或者Thread(Runnable)：构造线程。
Thread.start：启动线程。
Thread.sleep：将线程切换至休眠状态。
Thread.interrupt：中断线程的执行。
Thread.join：等待某线程结束。
Thread.yield：剥夺线程在CPU上的执行时间片，等待下一次调度。
Object.wait：将Object上所有线程锁定，直到notify方法才继续运行。
Object.notify：随机唤醒Object上的1个线程。
Object.notifyAll：唤醒Object上的所有线程。

　　下面，就是演示时间啦！！！

　　线程等待与唤醒

　　这里主要使用Object.wait和Object.notify方法，请参见上面的notify实例。需要注意的是，wait和notify都必须针对同一个对象，当我们使用实现Runnable接口的方式来创建线程时，应该是在Runnable对象而非Thread对象上使用这两个方法。

　　线程的休眠与唤醒

Thread.sleep实例
public class SleepSample {

  public static void main(String[] args) throws InterruptedException
  {
    sleepTest();
  }

  private static void sleepTest() throws InterruptedException
  {
    Thread thread = new Thread()
    {
      public void run()
      {
        System.out.println("线程 " + Thread.currentThread().getName() + "将要休眠5分钟。");
        try
        {
          Thread.sleep(5*60*1000);
        }
        catch(InterruptedException ex)
        {
          System.out.println("线程 " + Thread.currentThread().getName() + "休眠被中断。");
        }
        System.out.println("线程 " + Thread.currentThread().getName() + "休眠结束。");
      }
    };
    thread.setDaemon(true);
    thread.start();
    Thread.sleep(500);
    thread.interrupt();
  }

}

　　线程在休眠过程中，我们可以使用Thread.interrupt将其唤醒，这时线程会抛出InterruptedException。

　　线程的终止

　　虽然有Thread.stop方法，但该方法是不被推荐使用的，我们可以利用上面休眠与唤醒的机制，让线程在处理IterruptedException时，结束线程。

Thread.interrupt示例
public class StopThreadSample {

  public static void main(String[] args) throws InterruptedException
  {
    stopTest();
  }

  private static void stopTest() throws InterruptedException
  {
    Thread thread = new Thread()
    {
      public void run()
      {
        System.out.println("线程运行中。");
        try
        {
          Thread.sleep(1*60*1000);
        }
        catch(InterruptedException ex)
        {
          System.out.println("线程中断，结束线程");
          return;
        }
        System.out.println("线程正常结束。");
      }
    };
    thread.start();
    Thread.sleep(500);
    thread.interrupt();
  }
}

　　线程的同步等待

　　当我们在主线程中创建了10个子线程，然后我们期望10个子线程全部结束后，主线程在执行接下来的逻辑，这时，就该Thread.join登场了。

Thread.join示例
public class JoinSample {

  public static void main(String[] args) throws InterruptedException
  {
    joinTest();
  }

  private static void joinTest() throws InterruptedException
  {
    Thread thread = new Thread()
    {
      public void run()
      {
        try
        {
          for(int i = 0; i < 5; i++)
          {
            System.out.println("线程在运行。");
            Thread.sleep(1000);
          }
        }
        catch(InterruptedException ex)
        {
          ex.printStackTrace();
        }
      }
    };
    thread.setDaemon(true);
    thread.start();
    Thread.sleep(1000);
    thread.join();
    System.out.println("主线程正常结束。");
  }
}

　　我们可以试着将thread.join();注释或者删除，再次运行程序，就可以发现不同了。

　　线程间通信

　　我们知道，一个进程下面的所有线程是共享内存空间的，那么我们如何在不同的线程之间传递消息呢？在回顾 Java I/O时，我们谈到了PipedStream和PipedReader，这里，就是它们发挥作用的地方了。

　　下面的两个示例，功能完全一样，不同的是一个使用Stream，一个使用Reader/Writer。

PipeInputStream/PipedOutpueStream 示例
public static void communicationTest() throws IOException, InterruptedException
{
  final PipedOutputStream pos = new PipedOutputStream();
  final PipedInputStream pis = new PipedInputStream(pos);

  Thread thread1 = new Thread()
  {
    public void run()
    {
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      try
      {
        while(true)
        {
          String message = br.readLine();
          pos.write(message.getBytes());
          if (message.equals("end")) break;
        }
        br.close();
        pos.close();
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };

  Thread thread2 = new Thread()
  {
    public void run()
    {
      byte[] buffer = new byte[1024];
      int bytesRead = 0;
      try
      {
        while((bytesRead = pis.read(buffer, 0, buffer.length)) != -1)
        {
          System.out.println(new String(buffer));
          if (new String(buffer).equals("end")) break;
          buffer = null;
          buffer = new byte[1024];
        }
        pis.close();
        buffer = null;
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };

  thread1.setDaemon(true);
  thread2.setDaemon(true);
  thread1.start();
  thread2.start();
  thread1.join();
  thread2.join();
}

PipedReader/PipedWriter 示例
private static void communicationTest2() throws InterruptedException, IOException
{
  final PipedWriter pw = new PipedWriter();
  final PipedReader pr = new PipedReader(pw);
  final BufferedWriter bw = new BufferedWriter(pw);
  final BufferedReader br = new BufferedReader(pr);

  Thread thread1 = new Thread()
  {
    public void run()
    {

      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
      try
      {
        while(true)
        {
          String message = br.readLine();
          bw.write(message);
          bw.newLine();
          bw.flush();
          if (message.equals("end")) break;
        }
        br.close();
        pw.close();
        bw.close();
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };

  Thread thread2 = new Thread()
  {
    public void run()
    {

      String line = null;
      try
      {
        while((line = br.readLine()) != null)
        {
          System.out.println(line);
          if (line.equals("end")) break;
        }
        br.close();
        pr.close();
      }
      catch(Exception ex)
      {
        ex.printStackTrace();
      }
    }
  };

  thread1.setDaemon(true);
  thread2.setDaemon(true);
  thread1.start();
  thread2.start();
  thread1.join();
  thread2.join();
}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

15个高级Java多线程面试题及回答

Java 线程面试问题在任何Java面试当中多线程和并发方面的问题都是必不可少的一部分.如果你想获得任何股票投资银行的前台资讯职位,那么你应该准备很多关于多线程的问题.在投资银行业务中多线程和并发是一个非常受欢迎的话题,特别是电子交易发展方面相关的.他们会问面试者很多令人混淆的Java线程问题.面试官只是想确信面试者有足够的Java线程与并发方面的知识,因为候选人中有很多只浮于表面.用于直接面向市场交易的高容量和低延时的电子交易系统在本质上是并发的.下面这些是我在不同时间不同地点喜欢问的Jav
Java多线程实现异步调用的方法

在JAVA平台,实现异步调用的角色有如下三个角色:调用者提货单真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据. 去蛋糕店买蛋糕,不需要等蛋糕做出来(假设现做要很长时间),只需要领个提货单就可以了(去干别的事情),等到蛋糕做好了,再拿提货单取蛋糕就可以了. public class Main { public static void main(String[] args) { System.out.println("ma
java基本教程之Thread中start()和run()的区别 java多线程教程

Thread类包含start()和run()方法,它们的区别是什么?本章将对此作出解答.本章内容包括:start() 和 run()的区别说明start() 和 run()的区别示例start() 和 run()相关源码(基于JDK1.7.0_40) start() 和 run()的区别说明start() : 它的作用是启动一个新线程,新线程会执行相应的run()方法.start()不能被重复调用.run() : run()就和普通的成员方法一样,可以被重复调用.单独调用run()的话,会在
Java多线程下载的实现方法

复制代码代码如下: package cn.me.test; import java.io.InputStream; import java.io.RandomAccessFile; import java.net.HttpURLConnection; import java.net.URL; /** * 多线程下载 * 1:使用RandomAccessFile在任意的位置写入数据. * 2:需要计算第一个线程下载的数据量,可以平均分配.如果不够平均时, * 则直接最后一个线程处理相对较少
详解三种java实现多线程的方式

java中实现多线程的方法有两种:继承Thread类和实现runnable接口. 1.继承Thread类,重写父类run()方法 public class thread1 extends Thread { public void run() { for (int i = 0; i < 10000; i++) { System.out.println("我是线程"+this.getId()); } } public static void main(String[] args) {
Java中对AtomicInteger和int值在多线程下递增操作的测试

Java针对多线程下的数值安全计数器设计了一些类,这些类叫做原子类,其中一部分如下: java.util.concurrent.atomic.AtomicBoolean; java.util.concurrent.atomic.AtomicInteger; java.util.concurrent.atomic.AtomicLong; java.util.concurrent.atomic.AtomicReference; 下面是一个对比 AtomicInteger 与普通 int 值在多线
java多线程编程之使用Synchronized块同步变量

下面的代码演示了如何同步特定的类方法: 复制代码代码如下: package mythread; public class SyncThread extends Thread{ private static String sync = ""; private String methodType = ""; private static void method(String s) { synchronized (sync) {sync = s;System.out
Java多线程之中断线程(Interrupt)的使用详解

interrupt方法 interrupt字面上是中断的意思,但在Java里Thread.interrupt()方法实际上通过某种方式通知线程,并不会直接中止该线程.具体做什么事情由写代码的人决定,通常我们会中止该线程. 如果线程在调用Object类的wait().wait(long)或wait(long, int)方法,或者该类的 join() .join(long) .join(long, int) .sleep(long) 或 sleep(long, int) 方法过程中受阻,则其中断状态
java向多线程中传递参数的三种方法详细介绍

在传统的同步开发模式下,当我们调用一个函数时,通过这个函数的参数将数据传入,并通过这个函数的返回值来返回最终的计算结果.但在多线程的异步开发模式下,数据的传递和返回和同步开发模式有很大的区别.由于线程的运行和结束是不可预料的,因此,在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据.本文就以上原因介绍了几种用于向线程传递数据的方法,在下一篇文章中将介绍从线程中返回数据的方法. 欲先取之,必先予之.一般在使用线程时都需要有一些初始化数据,然后线程利用这些数据进行加工处理,并
java多线程和并发包入门示例

一.java多线程基本入门java多线程编程还是比较重要的,在实际业务开发中经常要遇到这个问题. java多线程,传统创建线程的方式有两种. 1.继承自Thread类,覆写run方法. 2.实现Runnable接口,实现run方法. 启动线程的方法都是调用start方法,真正执行调用的是run方法.参考代码如下: 复制代码代码如下: package com.jack.thread; /** * 线程简单演示例子程序 * * @author pinefantasy * @since 2013-

java 基础教程之多线程详解及简单实例

相关推荐

随机推荐