java学习笔记多线程学习总结(上)

时间:2022-04-27 00:16:49


一、进程的简述

     

1、进程:

是一个正在执行中的程序。每一个进程执行都有一个执行顺序,该顺序是一个执行路径,或者叫一个控制单元。Java中主线程要运行的代码在main中存储,自定义线程存在run中。

2、线程:

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

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

3、扩展:

其实更细节说明jvm,jvm启动不止一个线程,还有负责垃圾回事机制的线程。

4、多线程存在的意义:

使程序的部分产生同时运行效果,提高效率。


二、创建进程

1、如何在自定义的代码中,自定义一个线程呢?

   继承Thread类,重写run()方法。创建步骤:

  1、定义类继承Thread

  2、复写Thread类中的run方法(目的是:将自定义代码存储在run方法,让线程运行)

  3、调用线程的start方法,该方法有2个作用:启动线程、调用run方法。

  eg:class Demo extends Thread      // 定义一个线程类

     {

        public void run()    // 重写run方法

        {

           for(int x=0;x<60;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<60;x++)

           System.out.println(“Hello world!..”+x);    // 主线程

     }

  }

2、实现Runnable接口,覆写run方法。详细步骤:

      1、定义类实现Runable接口。

      2、覆盖Runable接口中的run方法。将线程要运行的代码放在该run方法中。

      3、通过Thread类建立线程对象。

      4、将Runable接口的子类对象作为实际参数传递给Thread类的构造函数(为什么要将Runable 接口的子类对象传            递给Thread的构造函数)因为,自定义的run方法所属的对象是Runable接口的子类对象,所以要让线程去指              定指定对象的run方法。就必须明确该run方法所属对象。

      5、调用Thread类的start方法,开启线程,并调用Runable接口子类的run方法。

eg:classTicket implements Runnable  // (extendsThread)   // 定义类实现Runnable接口用于创建线程

{

  private void run()     // 实现run方法

   {

      while(true)

      {

          if(ticket>0)        // 票数大于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(t2);

     t1.start();         //  启动线程

     t2.start();

   }

}

3、实现方式和继承方式的区别?

      1、实现方式的好处,避免了单继承的局限性。在定义线程时,建立使用实现方式。

      2、继承Thread:线程代码存放Thread子类run方法中,实现Runable,线程代码存在接口的子类的run方法。

注:发现程序运行结果每一次都不同,以newi多个线程都获取cpu的执行权。cpu执行到谁,谁就运行。明确一点,在某一个时刻,只能有一个程序在运行(多核除外)cpu做着快速的切换,以达到看上去是同时运行的效果。我们可以形象地把多线程的运行认为在互相抢夺cpu的执行权。这就是多线程的一个特性:随机性,谁抢到谁执行。至于执行多长时间,Cpu说的算。



三、线程的四种常见状态:

1、New(新创建)

2、Runnable(可运行)

3、Blocked(被阻塞)

4、Waiting(等待)

5、Timed waiting(计时等待)

6、Terminated(被终止)


四、线程的方法介绍

1、staticThread currentThread();   返回当前正在执行的线程对象。静态方法

2、getName();  获取线程名称。

3、设置线程名称:setName或者构造函数。调用父类构造super(name);


五、线程的同步

多线程当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误。

解决办法:

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

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

同步代码块的格式:Synchronized(对象){   需要被同步的代码   }

说明:那些语句要操作共享数据,那些语句就需要同步。

eg: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);}    // 停止10秒看效果

                  catch(Exception e)

                  {    }

                 System.out.println(Thread.currentThread().getName()+”..sale:”+tick--);

             }

         }

     }

   }

}

同步代码块的对象参数相当于锁,持有锁的线程可以在同步中执行,没有持有锁的线程即便获取cpu的执行权,也进不去,因为没有获取锁。

同步的前提:

      1、必须要有2个或2个以上的线程。

      2、多个(必须)多个线程使用同一个锁(必须保证同步中只能有一个线程在运行)

同步代码块的好处:解决了多线程的安全问题。

同步代码块的弊端:多个线程需要判断锁,较为消耗资源。

如何找出同步问题:

  1、明确哪些代码是多线程运行代码(run中代码及run中调用代码)

  2、明确共享数据。

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

同步有2种表现形式:同步代码块和同步函数。

同步函数封装的定要是需要同步的语句(例如while循环不能放)

同步代码块封装代码,唯一的区别是他带着同步性,若让函数具备同步性,就可以。


六、同步锁

同步函数用的是哪一个锁?

函数需要被对象调用,那么函数都有一个所属对象引用就是this,所以同步函数的使用锁是this。证明实例如下:

class Ticket implements Runnable

   {

     private int tick = 1000;

      Booleanflag = true;

     public void run()

     {

        if(flag)

        {

           while(true)

           {

               Synchronized(this)

              {

                  if(tick>0)

                  {

                     try{   Thread.sleep(10);   }catch(Exception e){   }

                  }

                  else

                     while(true)

                        (this.)show();

              }

             

              System.out.println(Thread.currentThread().getName()+”…sale:”+tick--);

           }

        }

     }

   }

  class ThisLockDemo

   {

     public static void main(String[] args)

     {  

         Ticket t = new Ticket();  

         Thread t1 = new Thread(t);

         Thread t2 = new Thread(t);

         t1.start();             //  一线程开始用同步代码块

         t.flag = false;             //  二线程开始用同步函数

         t2.start();

     }

   }

如果同步函数被静态修饰后,使用的锁是什么呢?

通过验证发现不是this,因为静态方法中也不可以定义this。

静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象。就是类名.class。该对象的类型是class(可以通过getClass()方法获取)。静态的同步方法使用的锁是该方法所在类的字节码文件对象,类名.class。且此对象在内存中是唯一的。


七、死锁

死锁,同步嵌套同步。在编写程序过程中要尽量避免死索。

创建一个死锁程序的例子:

class Test implements Runnable

{

  private Boolean flag;

  Test(Boolean flag)

  {   this.flag = flag;   }

  public void run()

   {

     if(flag)

     {  

         while(true)

         {

             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(“elselocka”);

             }

         }

     }

   }

}

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));    Thread t2 = new Thread(new Test(false));

     t1.start();      t2.start();

   }

}