【J2SE快速进阶】——Java多线程机制

简介: 学习Java中的线程时,自然而然地联想到之前学过的操作系统中处理器那一块的知识。

      定义

      文章开头,先大概说一下程序、进程和线程的概念及其之间的关系。


      程序:程序就是一段静态的代码,或者一个可执行程序。


      进程:进程是程序的一次动态执行的过程,它对应着从代码加载、运行到结束的一次动态的执行过程。


      线程:比进程更小的执行单位,一个进程在执行过程中,可以产生多个线程,也就是多个分支。它是程序执行流的最小单位。


      来看一个小程序:


public class Test {
  public static void main(String[] args) {
    fun1();
  }
  public static void fun1(){
    System.out.println(fun2()+fun3());    
  }
  public static String fun2(){
    return "Hello ";
  }
  public static String fun3(){
    return "World!";
  }
}


   它的执行顺序如下,在main方法中,从①执行到⑥是一条线,并没有分支,这就是一个线程。

78.png


       线程的实现


       当JVM执行到main方法时,就会启动一个线程,叫做主线程。如果main方法中还创建了其他线程,那么JVM就会在主线程和其他线程之间轮流切换,保证每个线程都有机会使用CPU资源。


      Java中的线程是通过java.lang.Thread类来实现的,每一个Thread对象都代表一个新的线程。


      Java中实现线程有两种方法:

      1、继承Thread类,并且重写其run方法(用来封装整个线程要执行的命令),调用start方法启动线程。


      比如下面这个类T要实现线程,则代码如下:


public class CreateThreadTest{
  public static void main(String[] args) {
    T r=new T();
    r.start();   //T类的线程开始执行
    for(int i=0;i<100;i++)
    {
      System.out.println("主线程正在执行~~~~"+i);
    }
  }
}
class T extends Thread
{
  public void run(){//重写父类中的run方法
    for(int i=0;i<100;i++)
    {
      System.out.println("我创建的线程正在执行~~~~"+i);
    }
  }
}


      现在,这一个小程序一共有两个线程正在执行,一个是主线程,还有一个是T类创建的线程。


     

       2、实现Runnable接口


       还有一种方法就是让实现线程的类实现Runnable接口,实现Runnable接口中唯一的方法run(),然后把此类的实例当做Thread类的构造函数的参数,创建线程对象。


       例如上面的例子,还可以这样写:

public class CreateThreadTest {
  public static void main(String[] args) {
    T r=new T();
    Thread t=new Thread(r);    //创建线程对象
    t.start();    //T类的线程开始
    for(int i=0;i<100;i++)
    {
      System.out.println("主线程正在执行~~~~"+i);
    }
  }
}
class T implements Runnable 
{
  public void run(){
    for(int i=0;i<100;i++)
    {
      System.out.println("我创建的线程正在执行~~~~"+i);
    }
  }
}


      两种方法的实质就是,都需要重写run方法,最终都是由Thread类的start方法启动线程。


      温馨提示:因为Java中不支持多继承,所以实现线程时,一旦继承了Thread类,就无法再继承其他类了。但Java支持实现多个接口,所以推荐采用第二中方法,比较灵活。


      多线程

      多线程主要是为了同步完成多项任务,即同时执行多个线程。多线程把一个进程划分为多个任务,它们彼此独立地工作


      我们都知道,现在大部分操作系统比如Windows、Mac OS X、Unix、Linux等,都是支持多线程的,但我们平时所说的多线程,并不意味着CPU在同时会处理多个线程,每个CPU在同一个时间点只会处理一个线程,只不过速度太快了,处理的时间极短,以至于我们可以认为它是在同一个时间段可以处理多个线程。所以只有当你的机器是“双核”甚至“多核”时,才能实现真正意义上的多线程。                                              


      下面看一个多线程的例子:


       两个线程t1和t2的执行        


public class ThreadTest {
  public static void main(String[] args) {
    Thread t1=new Thread(new T1());
    Thread t2=new Thread(new T2());
    t1.start();t2.start();
  } 
}
class T1 implements Runnable{
  public void run(){
    for(int i=0;i<10;i++){
      System.out.println("线程1正在执行中------"+i);
      if(i==9){
        System.out.println("线程1执行已结束------"+i);
        break;
      }
    }
  }
}
class T2 implements Runnable{
  public void run(){
    for(int i=0;i<10;i++){
      System.out.println("线程2正在执行中------"+i);
      if(i==9){
        System.out.println("线程2执行已结束------"+i);
        break;
      }
    }
  }
}


        看下面的结果之前,先充分发挥你的大脑想一想到底结果应该是什么样子的~~

        执行结果:

80.gif


      是不是跟您预测的不一样呢?如果不加线程的话,本来的结果应该前十行都是线程1在执行,线程1执行完后线程2才开始执行,线程调度算法使得每个线程执行一会进入等待状态,再去执行另一个线程。


      线程中常用的方法

      如果亲手尝试过上面这个例子中,会发现这两个线程t1和t2谁先执行,谁后执行,谁执行多长时间等等这些都是不确定、不可控的。下面就说一下线程中常用到的几个方法。

      ★ void yield()方法


      在一个线程中,如果执行到yield()方法,那么这个线程就会让出CPU资源,暂停当前正在执行的线程对象,转而让CPU去执行其他具有相同优先级的线程。充分体现了线程乐于谦让的精神!


      例:i的值从0到99,每次输出线程实例的名字,当i是10的倍数时,执行yield方法。


 public class TestYield {
  public static void main(String[] args) {
    MyThread thread1=new MyThread("thread1");
    MyThread thread2=new MyThread("thread2");
    thread1.start();thread2.start();
  }
}
class MyThread extends Thread{
  MyThread(String name){
    super(name);
  }
  public void run(){
    for(int i=0;i<100;i++){
      System.out.println(getName()+":"+i);
      if(i%10==0){
        yield();
      }
    }
  }
}


      从结果中的前几条输出可以发现,对thread1来说,每当i是10的倍数时,进程就会让出,thread2进程执行;thread2也是如此:


81.png82.png


     注意: yield()方法会将当前运行的线程切换到可运行状态,但可能没有效果,因为实际中执行yield方法的线程还有可能被调度程序再次选中。


     


     ★ void sleep(long millis)方法和void sleep(long millis,int nanos)


      让线程休眠(暂停执行)指定的时间长度,参数millis的单位是毫秒,参数nanos的单位是纳秒。线程执行了sleep方法后就会进入阻塞状态,指定的时间段过后,线程进入可执行状态,等待被操作系统调度。


      例:      


import java.util.*;
public class TestSleep {
  public static void main(String[] args)
  {
    MyThread thread=new MyThread();
    thread.start();
  }
}
class MyThread extends Thread
{
  public void run()
  {
    while(true)
    {
      System.out.println("==="+new Date()+"===");
      try{
        sleep(1000);
      }catch(InterruptedException e){
        return;
      }
    }
  }
}


       看完代码您应该猜到结果了,每隔一秒都会输出当前时间,相当于一个定时器。这个程序一共有两个线程,主线程(即main方法)中出了执行thread线程就没有其他任务需要执行,所以这里可以看做只执行thread这一个线程,如果把例子中的sleep方法去掉,那么就会“唰唰唰”地不断输出当前时间(你的CPU风扇也会“唰唰唰”~~~~)。


83.png


        ★void join()方法


        上面说线程执行了yield方法时,会自动让出CPU资源,使状态由运行状态转换为可运行状态。join()方法可以说是恰恰相仿,当一个线程执行了join方法时,那么它就会一直执行下去直到这个线程结束。


       还是举例来说明:


public class TestJoin {  
    public static void main(String[] args) throws InterruptedException {  
        Thread t1 = new Thread(new ThreadA());  
        Thread t2 = new Thread(new ThreadB());  
        t1.start();  
        t1.join(); // t1线程开始执行后,它将继续执行下去,直到t1线程结束,否则绝不让出CPU  
        t2.start();  
        t2.join(); // t2线程开始执行后,它将继续执行下去,直到t1线程结束,否则绝不让出CPU  
    }  
}
class ThreadA implements Runnable {   
    public void run() {  
        for (int i=0;i<10;i++) {  
            System.out.println("A线程正在运行~~~~" + i);  
        }   
    }  
}   
class ThreadB implements Runnable {   
  public void run() {  
        for (int i=0;i<10;i++) {  
            System.out.println("B线程正在运行~~~~" + i);  
        }   
    }   
} 


      先来设想一下,加入t1和t2两个线程启动后不执行join方法,那么CPU给它们分配的执行时间和顺序就不一定相同,如左下图;如果t1和t2执行了join方法,那么它们一旦开始执行,就将执行到底,如右下图。


84.gif85.gif


       为什么要用多线程

       最后一个问题,为什么要用多线程?


       在论坛里看到一个大牛的比喻:单线程就是牛逼老板从头到尾一个人做完,另开一个线程就是老板掰出一件事情叫一个小弟去做,这个小弟的进入会加快整个事情的进展,但有时可能会做起事来碍手碍脚。


      当然,想要更深地理解多线程的精髓所在,光靠学这些理论还是不够的,更重要的还是在实践和项目中去挖掘和思考。


相关文章
|
3天前
|
Java 开发者 UED
掌握Java多线程编程:从基础到高级
【5月更文挑战第31天】本文深入探讨了Java多线程编程的核心概念,包括线程的创建、生命周期、同步机制以及高级并发工具。通过实际示例和代码片段,读者将学会如何有效地管理和协调线程,以编写高效且稳定的并发应用程序。
|
2天前
|
存储 安全 Java
深入理解Java堆栈:机制、特性与应用
深入理解Java堆栈:机制、特性与应用
6 1
|
2天前
|
Java 关系型数据库 MySQL
【Java——SPI机制详解】
SPI(Service Provider Interface),是JDK内置的一种服务提供发现机制,可以用来启用框架扩展和替换组件,主要是被框架的开发人员使用,比如java.sql.Driver接口,其他不同厂商可以针对同一接口做出不同的实现,MySQL和PostgreSQL都有不同的实现提供给用户,而Java的SPI机制可以为某个接口寻找服务实现。Java中SPI机制主要思想是将装配的控制权移到程序之外,在模块化设计中这个机制尤其重要,其核心思想就是 解耦。 当服务的提供者提供了一种接口的实现之后,需要在classpath下的META-INF/services/目录里创建一个以服务接口命名的
|
2天前
|
缓存 安全 Java
【Java——反射机制详解】
RTTI(Run-Time Type Identification)运行时类型识别。在《Thinking in Java》一书第十四章中有提到,其作用是在运行时识别一个对象的类型和类的信息。主要有两种方式:一种是“传统的”RTTI,它假定我们在编译时已经知道了所有的类型;另一种是“反射”机制,它允许我们在运行时发现和使用类的信息。 反射就是把java类中的各种成分映射成一个个的Java对象 例如:一个类有:成员变量、方法、构造方法、包等等信息,利用反射技术可以对一个类进行解剖,把个个组成部分映射成一个个对象。
|
2天前
|
Java 编译器 程序员
【Java ——异常机制详解】
try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。 catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。 finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物力资源(如数据库连接、网络连接和磁盘文件)。只有finally块,执行完成之后,才会回来执行try或者catch块中的return或者throw语句,如果finally中使用了return或者throw等终止方法的语句,则就不会跳回执行,直接停止。 throw – 用于抛出异常。
|
2天前
|
Java 编译器 测试技术
【Java 基础 - 注解机制详细解释】
不能使用关键字extends来继承某个@interface,但注解在编译后,编译器会自动继承java.lang.annotation.Annotation接口. 虽然反编译后发现注解继承了Annotation接口,请记住,即使Java的接口可以实现多继承,但定义注解时依然无法使用extends关键字继承@interface。 区别于注解的继承,被注解的子类继承父类注解可以用@Inherited: 如果某个类使用了被@Inherited修饰的Annotation,则其子类将自动具有该注解。
|
3天前
|
安全 算法 Java
Java中的并发编程技术:解锁高效多线程应用的秘密
Java作为一种广泛应用的编程语言,其并发编程技术一直备受关注。本文将深入探讨Java中的并发编程,从基本概念到高级技巧,帮助读者更好地理解并发编程的本质,并学会如何在多线程环境中构建高效可靠的应用程序。
|
3天前
|
Java
Java中多线程的常见实现方式
Java中多线程的常见实现方式
11 2
|
3天前
|
Java 调度
Java中的多线程编程:基础知识与实践
【5月更文挑战第31天】本文将深入探讨Java中的多线程编程,从基础知识到实践应用,全面解析多线程的概念、创建、同步以及在实际应用中的运用。我们将通过实例来展示如何在Java中有效地使用多线程,以提高程序的性能和响应速度。
|
3天前
|
安全 Java 测试技术
Java反射机制的技术性探索
Java反射机制的技术性探索