【黑马程序员】 java笔记——多线程与单例模式

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------

多线程

一、多线程详解

         a.进程

         b.线程（例：FlashGet）

         c.多线程存在的意义

         d.线程的创建方式

         e.多线程的特性

1.进程

进程是一个正在执行中的程序。

每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

2.线程

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

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

 

Java VM启动的时候会有一个进程java.exe.

该进程中至少一个线程负责java程序的执行。

而且这个线程运行的代码存在于main方法中。

该线程称之为主线程。

3.扩展

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

1.如何在自定义的代码中，自定义一个线程？

通过对api的查找，java已经提供了对线程这类事物的描述，就Thread类。

创建线程的第一种方式：继承Thread类。

4.步骤

1.定义类继承Thread。

2.复写Thread类中的run方法。

         目的：将自定义代码存储在run方法，让线程运行。

3.调用线程的start方法。

         该方法两个作用：启动线程，调用run方法。

代码体现：

 public class ThreadDemo extends Thread
    {
    public void run()
    {
     //代码实现
     for(int x=0; x<100; x++)
     {
      System.out.println(getName()+"***"+x);
     }
    }
    }

例：

 classTest extends Thread {
         privateString name;
         Test(Stringname)
         {
                   this.name=name;
         }
         publicvoid run()
         {
                   for(intx=0;x<60;x++)
                   {
                            System.out.println(name+"run..."+x);
                   }
         }
}
class ThreadTest
{
         publicstatic void main(String[] args)
         {
                   Testt1=new Test("one");
                   Testt2=new Test("two");
                   t1.start();
                   t2.start();
         //      t1.run();
         //      t2.run();
         }
}

发现运行结果每一次都不同。

因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。

明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）

cpu在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说了算。

为什么要覆盖run方法？

Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

5.线程运行状态

1.线程的生命周期包含状态:

新状态、就绪状态、阻塞状态、死亡状态

2.新状态

使用new刚刚创建完的Thread类的对象，还没有调用start()之前就是新状态！

3.就绪状态（可运行状态）

通过new a start() a就绪

通过阻塞a完成了阻塞a就绪

当调用了Thread对象的start()方法之后，这个线程就进入了就绪状态，或者我们称之为可运行状态。

当同时把100个线程都start()了，问：在某一个时间点上几个线程在运行？答案是一个，那么其他99个是什么状态啊？就绪状态。

4.运行状态

　　只能就绪状态才能到运行状态。

　　需要在就绪状态之后，由调度来分配运行时间片。

5.阻塞状态

线程运行一段时间后，应该休眠。这样可以给其他线程运行的机会！但有时间片来控制，也不会把程序搞的太卡了。

一般线程都会没有用完时间片就休眠了。

   休眠：当线程执行了Thread.sleep()时，那么主进入了休眠状态！当线程经过了指定的休眠毫秒时，就回到了就绪状态！

   等待：当线程执行了wait()方法，那么这个线程就晕过去了。只能等待其他线程调用notfiy()来唤醒（回到就绪）！这个东西，现在不研究！

   挂起：t.suspend()这个线程就挂起了，只能等待其他线程调用resume()方法才能回到就绪状态。这两个方法都过时了，你不能去用它！

   IO阻塞：当线程试图完成IO操作时，那么这个线程就进入了IO阻塞状态。只有完成了这个IO操作，才能回到就绪状态。

   锁定：当线程试图使用一个被另一线程占用资源时，这个线程就被锁定了。只有另一线程用完了这个资源，那么线程才能使用这个资源。

          当A线程需要使用资源o时，但现在o正在被B线程使用，这时A线程锁定了。直到B线程用完了o，然后A就回到了就绪状态。也就是说，A线程得不到o，它就不走了。

6.死亡状态

   当任务完成后，它就自然死亡。

   线程也能被枪毙了！调用Thread的stop()方法就是枪毙它,但stop()被作废了，不要用。

   当抛出了一个异常使run()方法异常返回时，线程也就是意外死亡！run()方法没有声明异常，这说明能让线程的run()方法返回的异常只能是RuntimeException。

二、创建线程方式一:继承thread类

1.子类覆盖父类中的run方法，将线程运行的代码存放在run中。

2.建立子类对象的同时线程也被创建。

3.通过调用start方法开启线程。

线程的四种状态图：

                             

线程运行状态图：

 

1.获取线程对象以及名称

创建两个线程，和主线程交替运行。

原来线程都有自己默认的名称。

Thread-编号该编号从0开始。

static Thread.currentThread():获取当前线程对象。

getName():获取线程名称。

设置线程名称：setName或者构造函数。

2.start方法和run方法的区别

start是开启线程并执行线程的run方法。

run仅仅是调用，线程创建了并没有运行。

wait（）等待， notify（）唤醒 等待执行后必须通过notify（）进行唤醒。

currentThread（）是获取当前对象，是静态的方法是可以通过类名进行调用的。

两个Thread类中的方法：

         getName：获取线程的名称。

         setName：设置线程的名称。

illegalThreadStateException：无效的线程异常。

如果想是线程必须是继承Thread或者是继承Thread的子类。

在创建线程对象的时候就要明确要使用那段代码，因为要使用的代码必须的放在run方法中。也就是放在复写了Thread类的子类中的run方法中。

三、创建线程方式二：实现Runnable接口

 1. 步骤：

 （1）定义类实现Runnable接口

 （2）覆盖Runnable接口中的run方法。

                   将线程要运行的代码存放在该run方法中。

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

 （4）将Runnable接口的子类对象作为实际参数进行传递给Thread类的构造函数。

                   为什么要将Runnable接口的子类对象传递给Thread的构造函数。

因为，自定义的run方法所属的对象是runnable接口的子类对象，所以要让线程去调用指定对象的run方法，就必须明确run方法所属的对象。

 （5）调用Thread类的start方法开启线程并调用Runnable接口子类中的run方法。

实现方式（Runnable接口）和继承方式（Thread类）有什么区别？

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

         存放的位置不一样：

        继承是存放在Thread类的子类中，而实现是存放在Runnable的子类中。

2.两种方式区别

继承Thread:线程代码存放Thread子类run方法中。

实现Runnable，线程代码存在接口的子类的run方法。

四、多线程的安全问题

多线程的运行出现了安全问题。

1.问题的原因

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

2.解决办法

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

Java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块。

synchronized块的语法格式：

 

synchronized(对象)

{

    需要被同步的代码

}

3.多线程同步代码块

对象如同锁，持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

例如：火车上的卫生间———经典。

4.同步的前提

1．  必须要有两个或者两个以上的线程。

2．  必须是多个线程使用同一个锁。

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

好处：解决了多线程的安全问题。

弊端：多个线程需要判断锁，较为消耗资源。

 

多线程—同步函数的锁是this

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

函数需要被对象调用，那么函数都有一个所属对象引用。就是this。

所以同步函数使用的锁是this。

通过该程序进行验证。

使用两个线程来买票。

一个线程在同步代码块中。

一个线程在同步函数中。

都在执行买票动作。

例：

同步代码块：

Object obj=new Object();
While(true)
{
         synchronized(obj)
         {
                   if(tick>0)
                   {
                            try{Thread.sleep(10);}catch(Exceptione){}
                            System.out.println(Thread.currentThread().getName()+”…code:”+tick--);
                   }
         }
}

同步函数：

public synchronized void show()   //this
{
         If(tick>0)
         {
                   try{Thread.sleep(10);}catch(Exceptione){}
                            System.out.println(Thread.currentThread().getName()+”…show…:”+tick--);
 
         }
}

多线程—静态同步函数的锁是class对象

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

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

静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class   该对象的类型是class

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class

五、单例设计模式

1.饿汉式

//饿汉式
class Single
class Single
{
         Privatestatic final Single s=new Single();
         PrivateSingle() {}
         Publicstatic Single getInstance()
         {
                   Returns;
         }
}

2.懒汉式

//懒汉式
class Single
{
         Privatestatic Single s=null;
         PrivateSingle(){}
         Publicstatic Single getInstance()
         {
                   if(s==null)
                   {
                            Synchronized(Single.class)
                            {
                                     if(s==null)
                                               s=newSingle();
                            }
                   }
                   returns;
         }
}

3.单例模式中懒汉式的隐患

if(instance == null) {
    instance = new Single();
}
return instance;

 给懒汉添加同步

if(instance == null) {
synchronized(Single.class) {
    instance = new Single();
}
}
return instance;

隐患依然存在

 

同步块内使用判断

synchronized(Single.class) {
    if(instance == null) {
instance = new Single();
    }
}
return instance;

隐患是没有了，但效率低下

双重判断

If(instance == null) {
synchronized(Single.class) {
       if(instance == null) {
instance = new Single();
       }
}
}
return instance;
If(instance == null) {
synchronized(Single.class) {
       if(instance == null) {
instance = new Single();
       }
}
}
return instance;

如果在使用单例的设计模式的时候建议是用饿汉式，因为懒汉式会有加载延迟，加载延迟会出现安全问题，出现问题时候可以加载同步函数，但是加同步函数的时候会使其低效，但是可以使用双重判定可以解决低效的问题。

死锁：就是同步中嵌套同步就产生了死锁。

---------------------- ASP.Net+Android+IOS开发、 .Net培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net