java学习笔记多线程学习总结（上）

一、进程的简述

     

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();

   }

}