深入理解Java中的线程

最新推荐文章于 2024-08-17 15:25:50 发布

一只懒得睁眼的猫

最新推荐文章于 2024-08-17 15:25:50 发布

阅读量2.2k

点赞数 2

分类专栏： JavaSe JavaSe-Skill 文章标签： Java 线程

本文链接：https://blog.csdn.net/a2011480169/article/details/52525363

版权

JavaSe 同时被 2 个专栏收录

32 篇文章 1 订阅

订阅专栏

JavaSe-Skill

23 篇文章 6 订阅

订阅专栏

核心内容:
1、Java中线程的概念以及注意事项
2、Java中创建线程的两种方式
3、Java中创建线程两种方式的比较
4、线程同步的问题、线程同步问题的由来、如何解决线程同步的问题

1、Java中线程的概念以及注意事项

线程的概念:
①线程是一个程序里的不同执行路径；
②以前所编写的程序，每个程序都只有一个入口、一个出口以及一个顺序执行的序列，在程序执行过程中的任何指定时刻，都只有一个单独的执行点；
③事实上，在单个程序的内部是可以在同一时刻进行多种运算的，这就是所谓的多线程。

线程的注意事项:
①aa.start()具有两层含义:向下开辟(创建)一个新的线程,并执行本线程所对应的run方法；
②执行一个线程实际上就是执行本线程所对应的run方法中的代码；
③执行完aa.start()之后并不表示aa对象所对应的线程立即得到执行，aa.start()执行完之后只是表明aa对象所对应的线程具有了可以被cpu执行的资格，但由于想抢占cpu执行的线程很多，cpu并不一定会立即去执行aa对象所对应的线程，此时aa对象对应的线程将处于阻塞状态。一个线程对应三种不同的状态：阻塞状态、就绪状态、运行状态
④一个Thread对象能且只能代表一个线程

2、Java中创建线程的两种方式

Java中创建线程有两种方式:
①继承Thread类，并重写run方法
②实现Runnable接口，并实现run方法

实例程序1:继承Thread类,并重写run方法的方式创建线程

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      A aa = new A();
      aa.start(); //aa.start具有两层含义:向下开辟(创建)一个新的线程,并执行本线程所对应的run方法
      while(true)
      {
          System.out.println("Hadoop");
      }  
   }    
}
class A  extends Thread
{
   @Override
   public void run()
   {
      while(true)
      {
          System.out.println("Spark");
      }
   }
}

运行结果:hadoop与spark交替的输出

Spark
Spark
Spark
Spark
Spark
Spark
Spark
Spark
Spark
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop

实例程序2:实现Runnable接口,并实现其中的run方法的方式创建线程

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      Thread aa = new Thread(new A());
      aa.start(); //aa.start具有两层含义:向下开辟(创建)一个新的线程,并执行本线程所对应的run方法
      while(true)
      {
          System.out.println("Hadoop");
      }  
   }    
}
class A  implements Runnable
{
   public void run()  
   {
      while(true)
      {
          System.out.println("Spark");
      }
   }
}

运行结果:hadoop与spark交替的输出

Spark
Spark
Spark
Spark
Spark
Spark
Spark
Spark
Spark
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop
Hadoop

从上面创建线程的两种方式可以看出,无论通过哪种方式创建线程，必须调用Thread类中的start方法才能开辟一个新的线程。

3、Java中创建线程两种方式的比较

为什么Java要提供两种方法来创建线程呢？它们都有哪些区别？相比而言，哪一种方法更好呢？在给出具体结论之前，我们先用Java中的线程编程实现生活中的几个具体场景：

场景1:假设一个影院有三个售票口，分别用于向儿童、成人和老人售票。影院为每个窗口放有100张电影票，分别是儿童票、成人票和老人票。三个售票口各自售票,互不影响。

①、通过继承Thread类的方式来完成这个程序

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      A t1 = new A();
      A t2 = new A();
      A t3 = new A();
      t1.setName("儿童窗口");
      t2.setName("成人窗口");
      t3.setName("老人窗口");
      //同时开辟三个子线程
      t1.start();
      t2.start();
      t3.start();
   }    
}
class A extends Thread
{
   public int tickets = 100;
   @Override 
   public void run()
   {
      while(true)
      {
          if(tickets > 0)
          {
              System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
              tickets--;
          }
      }
   }
}

②、通过实现Runnable接口的方式来完成这个程序

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      Thread t1 = new Thread(new A());
      Thread t2 = new Thread(new A());
      Thread t3 = new Thread(new A());
      t1.setName("儿童窗口");
      t2.setName("成人窗口");
      t3.setName("老人窗口");
      //同时开辟三个子线程
      t1.start();
      t2.start();
      t3.start();
   }    
}
class A  implements Runnable
{
   public int tickets = 100;
   public void run()
   {
      while(true)
      {
          if(tickets > 0)
          {
              System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
              tickets--;
          }
      }
   }
}

运行结果(部分截取):

老人窗口正在售第:53张票
成人窗口正在售第:12张票
老人窗口正在售第:52张票
成人窗口正在售第:11张票
老人窗口正在售第:51张票
成人窗口正在售第:10张票
老人窗口正在售第:50张票
成人窗口正在售第:9张票
老人窗口正在售第:49张票
成人窗口正在售第:8张票
老人窗口正在售第:48张票
成人窗口正在售第:7张票
老人窗口正在售第:47张票
成人窗口正在售第:6张票
老人窗口正在售第:46张票
成人窗口正在售第:5张票
老人窗口正在售第:45张票
成人窗口正在售第:4张票
老人窗口正在售第:44张票
成人窗口正在售第:3张票

在上面的这个实例场景中，不同的售票口相当于不同的线程,不同种类的票相当于不同的资源。
可以总结出:若多个线程处理的是不同的资源,两种创建线程的方式均可。

场景2:有3个售票口,共同售出电影院的1000张票,3个售票口相当于3个线程,处理的是相同的资源(1000张电影票)

①、通过继承Thread类的方式来完成这个程序

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      A t1 = new A();
      A t2 = new A();
      A t3 = new A();

      t1.setName("窗口1");
      t1.start();
      t2.setName("窗口2");
      t2.start();
      t3.setName("窗口3");
      t3.start();

   }    
}
class A  extends Thread
{
   public static  int tickets = 1000; //静态的属性和方法属于类本身的,由操作系统只分配一块内存空间
   public static  String str = "Java";
   public void run()
   {
      while(true)
      {
          synchronized(str) //创建同步代码块
          {
              if(tickets > 0)
              {
                  System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
                  tickets--;
              }
          }
      }
   }
}

运行结果:(部分截图)

窗口1正在售第:202张票
窗口1正在售第:201张票
窗口1正在售第:200张票
窗口1正在售第:199张票
窗口2正在售第:198张票
窗口2正在售第:197张票
窗口2正在售第:196张票
窗口2正在售第:195张票
窗口2正在售第:194张票
窗口2正在售第:193张票

②、通过实现Runnable接口的方式来完成这个程序

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      A target = new A(); //三个售票口处理的是相同的资源,所以我们new出一个对象
      Thread t1 = new Thread(target);
      Thread t2 = new Thread(target);
      Thread t3 = new Thread(target);

      t1.setName("窗口1");
      t1.start();
      t2.setName("窗口2");
      t2.start();
      t3.setName("窗口3");
      t3.start();

   }    
}
class A  implements Runnable
{
   public int tickets = 1000;  
   public void run()
   {
      while(true)
      {
          synchronized(this) //创建同步代码块
          {
              if(tickets > 0)
              {
                  System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
                  tickets--;
              }
          }
      }
   }
}

运行结果:(部分截图)

窗口2正在售第:966张票
窗口2正在售第:965张票
窗口2正在售第:964张票
窗口2正在售第:963张票
窗口2正在售第:962张票
窗口2正在售第:961张票
窗口1正在售第:960张票
窗口1正在售第:959张票
窗口1正在售第:958张票
窗口1正在售第:957张票
窗口1正在售第:956张票
窗口1正在售第:955张票
窗口1正在售第:954张票

可以总结出:若多个线程处理的是相同的资源,最好通过实现Runnable接口的方式创建线程,不然的话通过继承Thread的方式显得过于繁琐。

4、Java中线程同步的问题，线程同步问题的由来，如何解决线程同步的问题/td>

什么是线程同步？
所谓线程同步就是多个线程在处理相同资源的时候，保证共享数据的数据一致性和变化一致性

线程同步问题的由来？
导致线程同步的原因共有两个:
①多个线程彼此之间处理的是相同的资源(比如3个窗口共同售出1000张票)
②多个线程彼此之间在处理相同关键步骤的时候,在这些关键的步骤没有执行完毕的时候,CPU会切换到另外一个线程去执行这些关键的步骤,导致共享数据的一致性出现问题

实例程序:(线程同步出错)

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      A target = new A(); //三个售票口处理的是相同的资源,所以我们new出一个对象
      Thread t1 = new Thread(target);
      Thread t2 = new Thread(target);
      Thread t3 = new Thread(target);

      t1.setName("窗口1");
      t1.start();
      t2.setName("窗口2");
      t2.start();
      t3.setName("窗口3");
      t3.start();

   }    
}
class A  extends Thread
{
   public int  tickets = 1000; 
   public void run()
   {
      while(true)
      {  
          if(tickets > 0)
          {
              System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
              tickets--;
          }
      }
   }
}

运行结果:(部分截取)

窗口2正在售第:10张票
窗口2正在售第:9张票
窗口2正在售第:8张票
窗口2正在售第:7张票
窗口2正在售第:6张票
窗口2正在售第:5张票
窗口2正在售第:4张票
窗口2正在售第:3张票
窗口2正在售第:2张票
窗口2正在售第:1张票
窗口1正在售第:113张票
窗口3正在售第:111张票

从上面的程序可以看出,3个线程在处理相同资源的时候(1000张票)的时候，共享数据的一致性出现了问题，其原因在于:

 if(tickets > 0)
 {
    System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
    tickets--;
 }

这个代码块并不是一个不可分割的整体。

在Java当中,如何解决线程同步的问题？
在Java当中是通过synchronized语法机制来解决线程同步的问题的,通过synchronized语法机制,保证这些关键的步骤在被某一个线程访问或者执行的时候,其余线程不能在执行这些关键的步骤(尽管CPU仍在多个线程之间来回切换)，直到这个线程将这些关键的步骤执行完毕,其余线程才能执行这些关键的步骤；
Java中的synchronized语法机制类似于数据库中的事务性处理机制。

实例程序:通过synchronized语法机制来解决上面的线程同步问题

public class App1
{  
   public static void main(String[] args) throws InterruptedException
   {
      A target = new A(); //三个售票口处理的是相同的资源,所以我们new出一个对象
      Thread t1 = new Thread(target);
      Thread t2 = new Thread(target);
      Thread t3 = new Thread(target);

      t1.setName("窗口1");
      t1.start();
      t2.setName("窗口2");
      t2.start();
      t3.setName("窗口3");
      t3.start();

   }    
}
class A  extends Thread
{
   public int  tickets = 1000; 
   public void run()
   {
      while(true)
      {
          synchronized(this) //创建同步代码块
          {
              if(tickets > 0)
              {
                  System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
                  tickets--;
              }
          }
      }
   }
}

运行结果：(截取部分)

窗口1正在售第:48张票
窗口1正在售第:47张票
窗口1正在售第:46张票
窗口1正在售第:45张票
窗口1正在售第:44张票
窗口1正在售第:43张票
窗口3正在售第:42张票
窗口3正在售第:41张票
窗口3正在售第:40张票
窗口3正在售第:39张票
窗口3正在售第:38张票
窗口3正在售第:37张票
窗口3正在售第:36张票

在上面的程序中,通过Java中的synchronized语法机制,保证了下面的代码块变成了一个不可分割的整体。

  synchronized(this) //创建同步代码块
  {
        if(tickets > 0)
        {
            System.out.println(Thread.currentThread().getName()+"正在售第:"+tickets+"张票");
            tickets--;
        }
  }

对于上面的讲解,如有问题,欢迎留言指正！