Java基础-11-多线程

最新推荐文章于 2024-03-17 21:20:55 发布

faith_yee

最新推荐文章于 2024-03-17 21:20:55 发布

阅读量299

点赞数

分类专栏： Java入门文章标签： java

本文链接：https://blog.csdn.net/faith_yee/article/details/44751323

版权

Java入门专栏收录该内容

30 篇文章 0 订阅

订阅专栏

Java基础-线程

线程入门

1、多线程（概念）

进程：正在进行的程序。而线程是进程中的内容。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。

一个进程中至少有一个线程。

Java VM启动的时候会有一个进程java.exe 该进程中至少一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中，该线程称之为主线程。

扩展：其实更细节说明JVM，JVM启动不止一个线程，还有负责垃圾回收机制的线程。

2、多线程（创建线程-继承Thread类）

如何在自定义的代码中，自定义一个线程呢？通过对JAVA-API的查找，java已经提供了对线程这类事物的描述，就是Thread类，创建线程的第一种方式：继承Thread类。

步骤：

（1）、定义类继承Thread类。
（2）、复写Thread类中的run方法：目的，将自定义的代码存储在run方法中，让线程运行。
（3）、调用线程的start方法：该方法两个作用，启动线程，调用run方法。

Eg：测试线程并观察其现象

class Demo extends Thread
{
        public void run()
        {
               for(int x = 0 ; x<5;x++)
               {
                       System.out.println("demo run....."+x);
               }
        }
}
class ThreadDemo
{
        public static void main(String []args)
        {
               Demo d = new Demo();   //创建好一个线程
               d.start();
               for(int x = 0;x<5;x++)
               {
                       System.out.println("Hello World!......"+x);
               }
        }
}

程序结果：

Hello World!......0
demo run.....0
Hello World!......1
demo run.....1
Hello World!......2
demo run.....2
demo run.....3
Hello World!......3
demo run.....4
Hello World!......4

注意，以上结果不一定每一次都相同，这是因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行，明确一点，在某一时刻，只能有一个程序（或线程）在运行，多核除外，cpu在做着快速的切换，以达到看上去是同时运行的效果，我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。这就是多线程的一个特性：随机性，谁抢到谁执行，至于执行多长，cpu说的算。

科普：Windows系统时多任务执行系统：它是交替执行程序，cpu进行快速切换，人感觉像是同时，更细地说也就是交替执行程序中的线程。

3、多线程（创建线程-run和start的特点）

为什么要覆盖run方法呢？ Thread类用于描述线程，该类就定义了一个功能，用于存储线程要执行的代码，该存储功能就是run方法。也就是说，Thread类中的run方法，用于存储线程要运行的代码。

d.start();//开启线程并执行线程的run方法。

d.run();//仅仅是对象调用方法，而线程创建了，并没有运行。

//注意以上的区别。

4、多线程（线程-练习）

//练习：创建两个线程，和主线程交替运行。

class Test extends Thread
{
        private String name;
        Test(String name)
        {
               this.name = name;

        }
        public void run()
        {
               for(int x = 0;x<60;x++)
               {
                       System.out.println(name+"run..."+x);
               }
        }
}
class ThreadTest
{
        public static void main(String []args)
        {
               Test t1 =new Test("one");
               Test t2 =new Test("two");
               //t1.start();//与别的线程产生交替
               //t2.start();//与别的线程产生交替
               t1.run();//不交替，按流程输出
               t2.run();//不交替，按流程输出
               for(int x = 0;x<60;x++)
               {
                       System.out.println("main...."+x);
               }
        }
}

5、多线程（线程运行的状态）

6、多线程（获取线程对象以及名称）

this.getName(); //获得线程对象名称，this代表调用该函数的线程对象。

//或者用以下方式替换
Thread.currentThread().getName();
Thread.currentThread();//获取当前线程对象。

线程都有自己默认的名称：Thread-编号
编号从0开始。

如何给线程赋予名字：

Thread(String name)   
//Thread类的构造函数可以传递字符串，即自定义线程名。
//或者使用setName方法来设置线程名称。

7、多线程（售票的例子）

/*
 * 需求：简单的卖票程序
 * 多个窗口同时卖票
 */
class Ticket extends Thread
{
        private static int tick = 100; //静态变量，为了让各对象共享。
        boolean flag = true;
        public void run()
        {
               while (flag)
               {
                       if(tick>0)
                       {

                               System.out.println(Thread.currentThread().getName()+"..."+tick--);
                       }
                       else flag = false;
               }
        }
}
class TicketDemo
{
        public static void main(String []args)
        {
               Ticket t1 = new Ticket();
               Ticket t2 = new Ticket();
               Ticket t3 = new Ticket();
               Ticket t4 = new Ticket();
               t1.start();
               t2.start();
               t3.start();
               t4.start();     
        }
}

输出结果：

8、多线程（创建线程-实现Runnable接口）

由于之前的售票例子程序中的定义的private static int tick = 100;存在于整个程序的使用过程中，太占内存空间。或者只建立一个线程对象而执行4次t1.start();，这样做也毫无意义。

Runnable接口：接口应该由那些打算通过某一线程执行其实例的类来实现，类必须定义一个称为run的无参数方法。

下面同样是售票的例子

class Ticket implements Runnable
{
        private int tick = 100;        //不用再使用static了
        public void run()
        {
               while (true)
               {
                       if(tick>0)
                       {
                               System.out.println(Thread.currentThread().getName()+"....sale:"+tick--);
                       }
               }
        }
}
class TicketDemo
{
        public static void main(String[]args)
        {
               Ticket t = new Ticket();
               Thread t1 = new Thread(t);
               Thread t2 = new Thread(t);
               Thread t3 = new Thread(t);
               Thread t4 = new Thread(t);
               t1.start();
               t2.start();
               t3.start();
               t4.start();
        }
}

输出结果：

创建线程的第二种方式：实现Runnable接口。步骤：

（1）、定义类实现Runnable接口
（2）、覆盖Runnable接口中的run方法，将线程要运行的代码存放在该run方法中。
（3）、通过Thread类建立线程的对象。
（4）、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
（5）、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

对于第四点，为什么要将Runnable接口的子类对象传递给Thread类的构造函数？因为，自定义的run方法所属的对象是Runnable接口的子类对象，所以要让线程去指定指定对象的run方法，就必须明确该run方法所属的对象。

对于继承Thread和实现Runnable接口两种方式有什么区别呢？继承Thread：线程代码存放Thread子类run方法中。实现Runnable：线程代码存放在接口的子类的run方法。

实现Runnable接口方式的好处：避免了单继承的局限性。在定义线程时建议使用实现Runnable接口方式。

9、多线程（多线程的安全问题）

Eg：以下演示将要出现安全隐患的代码

class Ticket implements Runnable
{
        private int tick = 100 ;
        public void run()
        {
               while (tick>0)
               {
                       if(tick>0)
                       {
                               try
                               {
                                      Thread.sleep(10);
                               }
                               catch(Exception e)
                               {

                               }
                               System.out.println(Thread.currentThread().getName()+"........sale:"+tick--);         
                       }
               }
        }
}
class TicketDemo
{
        public static void main(String[]args)throws Exception
        {
               Ticket t = new Ticket();
               Thread t1 = new Thread(t);
               Thread t2 = new Thread(t);
               Thread t3 = new Thread(t);
               Thread t4 = new Thread(t);
               t1.start();
               t2.start();
               t3.start();
               t4.start();
        }
}

程序结果：

Thread-3........sale:98
Thread-0........sale:97
Thread-2........sale:99
Thread-1........sale:100
.......(省略)
Thread-1........sale:1
Thread-2........sale:0
Thread-3........sale:-1
Thread-0........sale:-2

发现结果出现了-1，-2这种售票情况，这就是安全隐患。

原因如下图：

通过分析，发现打印出0，-1，-2等错票，这是多线程的运行出现了安全问题。原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。

解决方法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

Java对于多线程的安全问题提供了专业的解决方式，就是同步代码块。

synchronized(对象)
{
        需要同步的代码；
}

对出现了安全隐患的售票例子添加上同步代码块机制。

import java.lang.Object;
class Ticket implements Runnable
{
        private int tick = 100 ;
        Object obj =new Object();
        public void run()
        {
               while (true)
               {
                       synchronized(obj)//同步机制
                       {
                                      if(tick>0)
                                      {
                                              try
                                              {
                                                     Thread.sleep(10);
                                              }
                                              catch(Exception e)
                                              {                               
                                              }
                       System.out.println(Thread.currentThread().getName()+"........sale:"+tick--);                  
                                      }
                       }
               }
        }
}
class TicketDemo
{
        public static void main(String[]args)throws Exception
        {
               Ticket t = new Ticket();
               Thread t1 = new Thread(t);
               Thread t2 = new Thread(t);
               Thread t3 = new Thread(t);
               Thread t4 = new Thread(t);
               t1.start();
               t2.start();
               t3.start();
               t4.start();
        }
}

程序结果：

Thread-2........sale:100
Thread-2........sale:99
Thread-2........sale:98
...(省略)
Thread-0........sale:3
Thread-0........sale:2
Thread-0........sale:1

以上没有再出现-1，-2等情况了。

10、多线程（多线程同步代码块）

synchronized(obj){}里的对象obj如同锁，持有锁的线程可以在同步中执行。没有持有锁的线程即使取得cpu的执行权，也进不去，因为没有获取锁。

同步的前提：

（1）、必须要有两个或者两个以上的线程。
（2）、必须是多个线程使用同一个锁。

必须保证同步中只能有一个线程在运行。

好处：解决了多线程的安全问题。弊端：多个线程需要判断锁，较为消耗资源。

11、多线程（多线程-同步函数）

import java.lang.Object;
/*
 * 需求：
 * 银行有一个金库，有两个储户分别存储300元，每次存100，存3次。
 * 目的：该程序是否有安全问题，如果有，如何解决？
 */
class Bank
{
   private int sum ;
   public void add(int n )//问题出在这一被共享的功能函数内，线程t1，t2有可能同时进来对共享数据进行操作
   {
      sum = sum + n;
      try//为了测试，我们在此段代码上插入Thread.sleep();
      {
         Thread.sleep(10);
      }
      catch(Exception e)
      {
      }
      System.out.println("sum = " + sum );
   }
}
class Cus implements Runnable //实现线程接口
{
   private Bank b = new Bank();
   public void run()
   {
      for(int x = 0;x<3;x++)
      {
         b.add(100);
      }
   }
}
class Demo
{
   public static void main(String[]args)
   {
      Cus c = new Cus();
      Thread t1 = new Thread(c);
      Thread t2 = new Thread(c);
      t1.start();
      t2.start();
   }
}

程序结果：（每一次都不一定相同）

sum = 200
sum = 300
sum = 300
sum = 500
sum = 600
sum = 600

没有出现我们预期的结果：

sum = 100
sum = 200
sum = 300
sum = 400
sum = 500
sum = 600

如何找问题：

（1）、明确哪些代码是多线程运行代码。
（2）、明确共享数据。
（3）、明确多现线程运行代码中哪些语句是操作共享语句。

我们需要加入同步机制。改进代码如下：

import java.lang.Object;
class Bank
{
   private int sum ;
   Object obj = new Object();
   public void add(int n )//问题出在这一被共享的功能函数内，线程t1，t2有可能同时进来对共享数据进行操作
   {
      synchronized(obj)//加上了同步机制
      {
         sum = sum + n;
         try//为了测试，我们在此段代码上插入Thread.sleep();

         {
            Thread.sleep(10);
         }
         catch(Exception e)
         {
         }
         System.out.println("sum = " + sum );
      }
   }
}
class Cus implements Runnable //实现线程接口
{
   private Bank b = new Bank();
   public void run()
   {
      for(int x = 0;x<3;x++)
      {
         b.add(100);
      }
   }
}
class Demo
{
   public static void main(String[]args)
   {
      Cus c = new Cus();
      Thread t1 = new Thread(c);
      Thread t2 = new Thread(c);
      t1.start();
      t2.start();
   }
}

结果：

sum = 100
sum = 200
sum = 300
sum = 400
sum = 500
sum = 600

发现以上加了同步机制的程序没有出现隐患，可见，同步函数用来封装共享代码。

12、多线程（多线程-同步函数的锁是this）

注意：synchornized关键字还可以描述函数

之前的卖票的程序也可以改进成以下：（用同步函数封装代码）

class Ticket implements Runnable
{
   private int tick = 100;
   public void run()
   {
      while (true)
      {
         this.show();
      }
   }
   public synchronized void show()//利用同步函数封装代码
   {
      if(tick>0)
      {
         try
         {
            Thread.sleep(10);
         }
         catch(Exception e)
         {             
         }
         System.out.println(Thread.currentThread().getName()+"........sale:"+tick--);
      }
   }
}
class TicketDemo
{
   public static void main(String[]args)throws Exception
   {
      Ticket t = new Ticket();
      Thread t1 = new Thread(t);
      Thread t2 = new Thread(t);
      Thread t3 = new Thread(t);
      Thread t4 = new Thread(t);
      t1.start();
      t2.start();
      t3.start();
      t4.start();
   }
}

输出代码：

问题来了：同步函数用的是哪一个锁呢?

函数需要被对象调用，那么函数都有一个属于对象引用。就是this。所以同步函数使用的锁就是this，通过卖票程序来验证：使用两个线程来卖票

如下：

import java.lang.Object;
/*
 * 程序设置两个功能分别处理两个线程，而用标记变量的true和false来切换功能
 * 并且验证同步函数使用的锁是否为this
 */
class Ticket implements Runnable
{
   private int tick = 100   ;
   Object obj = new Object();
   boolean flag = false ;//true时选择同步代码块，false时选择同步函数
   public void run()
   {
         while(true)
         {
            if(flag)
            {
                synchronized(obj)
                /*若该对象不是obj而是其他对象，那么程序结果还是会出现隐患
                 * 出现0号票，若把obj该为this，程序就正常，因为这样才符合同步的前提
                */
                {
                   if(tick>0)
                   {
                      try
                      {
                         Thread.sleep(10);
                      }
                      catch(Exception e)
                      {                
                      }
                      System.out.println(Thread.currentThread().getName()+"........code:"+tick--);

                   }
                }     
            }
            else
            {
                while(true)
                {
                   show();//相当于this.show();此处也能证明同步函数的锁就是this
                }
            }
         }
      }
   public synchronized void show()
   {
      if(tick>0)
      {
         try
         {
            Thread.sleep(10);
         }
         catch(Exception e)
         {                 
         }
         System.out.println(Thread.currentThread().getName()+"........show:"+tick--);
      }
   }
}
class TicketDemo
{
   public static void main(String[]args)throws Exception
   {
      Ticket t = new Ticket();
      Thread t1 = new Thread(t);
      Thread t2 = new Thread(t);
      t1.start();
      t2.start();
   }
}

13、多线程（多线程-静态同步函数的锁是class对象）

如果同步函数被静态修饰后，使用的锁是什么？

通过验证（利用上一节课的双功能调用线程的例子，给函数加上static），程序结果又再出现安全隐患，所以发现静态进入内存是内存中没有本类对象，但是一定有该类对应的字节码文件对象，因此，静态的同步方法，使用的所是该方法所在类而定字节码文件对象：类名.class

14、多线程（多线程-单例设计模式-懒汉式）

之前学过的所谓单例设计模式有饿汉式和懒汉式。

饿汉式：

class Single
{
   private static final Single s = new Single();
   private Single(){}
   public static Single getInstance();
   {
      return s ;
   }
}

懒汉式（在多线程访问时会产生安全隐患）

class Single
{
   private static final Single s = null;
   private Single(){}
   public static Single getInstance();
   {
      if(s==null)
      {
         s = new Single();
      }
      return s ;
   } 
}

改进：加入同步代码块

class Single
{
   private static final Single s = null;
   private Single(){}
   public static Single getInstance();
   {
      if(s==null)//双重判断，减少重复判断
      {
         synchronized(Single.class)
         {
            if(s==null)
            {
                s = new Single();
            }
         }
      }
      return s ;
   } 
}

15、多线程（多线程-死锁）

死锁：同步中嵌套同步

import java.lang.Object;
class Test implements Runnable
{
    private boolean flag;
    Test(boolean flag)
    {
        this.flag = flag;
    }
    public void run()
    {
        if(flag)
        {
            synchronized(MyLock.locka)//同步中嵌套同步
            {
                System.out.println("if locka");
                synchronized(MyLock.lockb)
                {
                    System.out.println("if lockb");
                }
            }

        }
        else
        {
            synchronized(MyLock.lockb)//同步中嵌套同步
            {
                System.out.println("else lockb");
                synchronized(MyLock.locka)
                {
                    System.out.println("else locka");
                }
            }

        }
        /*
         * 对于线程执行以上的两个分支，如果其中一个线程执行的时间够短的话，这两支线程不会出现死锁情况
         * 但是如果其中一个线程执行if里的语句同时另一个线程开始执行else里的语句，
         * 冲突就发生了，if里的线程准备要执行语句里的同步代码块时发现其锁正在被else语句里的线程使用
         * 而else语句里的线程继续执行代码时也继续执行到同步代码块时也发现其锁正在被if语句里的线程使用
         * 因此两线程就处于了等待状态。程序停止运行，死锁发生。
         * */
    }
}
class MyLock
{
    static Object locka = new Object();
    static Object lockb = new Object(); 
}
class DeadLockTest
{
    public static void main(String[]args)
    {
        Thread t1 = new Thread(new Test(true));//该线程执行if里的代码
        Thread t2 = new Thread(new Test(false));//该线程执行else里的代码
        t1.start();
        t2.start();
    }
}

重复进行执行以上代码偶尔会死锁：

faith_yee

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础-11-多线程

Java基础-线程线程入门1、多线程（概念）进程：正在进行的程序。而线程是进程中的内容。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。一个进程中至少有一个线程。Java VM启动的时候会有一个进程java.exe 该进程中至少一个线程负责java程序的执行。而且这个线程运行
复制链接

扫一扫

专栏目录