黑马程序员_多线程

-------android培训、java培训、期待与您交流！-------

 

1．进程和线程概念

（1）进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

（2）线程：进程内部的一条执行路径或者一个控制单元。

（3）两者的区别：

一个进程至少有一个线程，进程在执行过程中拥有独立的内存单元，而多个线程共享内存；

2．Java VM的启动是多线程吗？

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

该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main 方法中。该线程称为主线程。jvm启动不止有一个线程，还有一个垃圾回收线程。所以该Jvm的运行也是多线程。

3.实现线程的两种方式

（1）第一种方式：继承Thread类。

a.定义类继承Thread的类。

b.复写Thread中的run()方法。目的：将自定义的代码存储在run方法，让start启动调用run方法。

c.调用线程的start方法。该方法的作用：启动线程，调用run方法。

注意继承Thread类实现线程常用方法：

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

getName( )获取线程名称。

设置线程名称setName()或者构造方法。

（2）第二种方式实现Runnable接口：

a.定义类实现Runnable接口

b.覆盖Runnable接口的run方法。将线程要运行的代码放在run方法中。

c.通过Thread类建立线程对象。

d.将Runnable接口的子类实例作为实参传递给Thread类的构造函数。

e.为什么要将Runnable接口的子类对象传递给Thread构造方法?

答：因为自定义的run方法所属的对象是Runnable接口的子类对象。

所以要让线程去指定对象的run方法。就必须明确该run方法所属对象。

f.调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

g.实现Runnable与继承Thread实现线程的区别？

两种方式的区别：

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

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

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

4．start()和run方法有什么区别？

（1）调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程。

（2）start()方法:

start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，它包含了要执行的这个线程的内容，run方法运行结束,此线程随即终止。

run()方法:

run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到多线程的目的。

 

5.线程的几种状态：

新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个时候，只是对象线程对象开辟了内存空间和初始化数据。就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。在这个状态的线程对象，具有执行资格，没有执行权。

运行：当线程对象获取到了CPU的资源。在这个状态的线程对象，既有执行资格，也有执行权。

冻结：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。当然，他们可以回到运行状态。只不过，不是直接回到。而是先回到就绪状态。

死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，在内存中变成了垃圾。

6.sleep()和wait()的区别：

(1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。

(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法。

(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；

(4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用

7.多线程安全问题：

(1)原因:当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性导致一个线程对多条语句，执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。

(2)解决方法:对多条操作共享数据的语句进行同步，一个线程在执行过程中其他线程不可以参与进来

8.Java中多线程同步是什么？

同步是用来解决多线程的安全问题的，在多线程中，同步能控制对共享数据的访问。如果没有同步，当一个线程在修改一个共享数据时，而另外一个线程正在使用或者更新同一个共享数据，这样容易导致程序出现错误的结果。

9.什么是锁?锁的作用是什么?

锁就是对象

锁的作用是保证线程同步，解决线程安全问题。

持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。

10.同步的前提:

(1)必须保证有两个以上线程

(2)必须是多个线程使用同一个锁，即多条语句在操作线程共享数据

(3)必须保证同步中只有一个线程在运行

11.同步的好处和弊端

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

弊端：多线程都需要判断锁，比较消耗资源

12.同步的两种表现形式：

(1)同步代码块:

可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象考虑到安全问题，一般还是使用同一个对象，相对来说效率较高。

注意：虽然同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，必须保证同步代码快的锁的对象和，否则会报错。

同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是同一个对象，也就是都是this锁代表的对象。

       格式：

       synchronized(对象)

       {

          需同步的代码;

       }

   (2)同步函数

       同步方法是指进入该方法时需要获取this对象的同步锁，在方法上使用synchronized关键字，

       使用this对象作为锁，也就是使用了当前对象，因为锁住了方法，所以相对于代码块来说效率相对较低。

       注:静态同步函数的锁是该方法所在的类的字节码文件对象，即类名.class文件

       格式：

       修饰词 synchronized 返回值类型函数名(参数列表)

       {

          需同步的代码;

       }

 

   在jdk1.5后，用lock锁取代了synchronized，个人理解也就是对同步代码块做了修改，

   并没有提供对同步方法的修改，主要还是效率问题吧。

13.同步锁解决单例模式中懒汉式存在的安全问题。

懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题，可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，所以可以加双重判断来提高程序效率。

       如将上述懒汉式的Instance函数改成同步：

       public static Single getInstance()

       {

          if(s==null)

          {

              synchronized(Single.class)

              {

                 if(s==null)

                     s=new Single();

              }

          }

          return s;

       }

14.死锁

（1）概念：两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。

（2）模拟死锁代码：

public class DreadthDemo{/* * (1)存在两个或者两个以上的线程  * (2)当有两个以上的同步代码的时候，A块有持有a锁，需要b锁才能够执行，B块有b锁需要a锁才能够继续执行。 *//** * @param args */public static void main(String[] args){DreadCode dreadCode = new DreadCode(true);DreadCode dreadCode2 = new DreadCode(false);new Thread(dreadCode).start();new Thread(dreadCode2).start();}}class DreadCode implements Runnable{boolean flag;public DreadCode(boolean b){this.flag = b;}/** * 死锁的代码：你中有我想要的，我中有你想要的，谁都不给...同死不共生。 */@Overridepublic void run(){if (flag){synchronized (Lock.locka){System.out.println("if Lock.locka");synchronized (Lock.lockb){System.out.println("if Lock.lockb");}}} else{synchronized (Lock.lockb){System.out.println("else Lock.lockb");synchronized (Lock.locka){System.out.println("else Lock.locka");}}}}}class Lock{static Object locka = new Object();static Object lockb = new Object();}

 

15．wait()、sleep()、notify()、notifyAll()概述

（1）wait():使一个线程处于等待状态，并且释放所持有的对象的lock。

（2）sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

（3）notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。

（4）notityAll ():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

16．为什么wait()、notify()、notifyAll()这些用来操作线程的方法定义在Object类中？

(1)这些方法只存在于同步中；

(2)使用这些方法时必须要指定所属的锁，即被哪个锁调用这些方法；

(3)而锁可以是任意对象，所以任意对象调用的方法就定义在Object中。

16．多线程间通讯：

多线程间通讯就是多个线程在操作同一资源,但是操作的动作不同。

(1)为什么要通信

多线程并发执行的时候, 如果需要指定线程等待或者唤醒指定线程, 那么就需要通信.比如生产者消费者的问题，生产一个消费一个,生产的时候需要负责消费的进程等待,生产一个后完成后需要唤醒负责消费的线程,同时让自己处于等待，消费的时候负责消费的线程被唤醒，消费完生产的产品后又将等待的生产线程唤醒，然后使自己线程处于等待。这样来回通信，以达到生产一个消费一个的目的。

(2)怎么通信

在同步代码块中, 使用锁对象的wait()方法可以让当前线程等待, 直到有其他线程唤醒为止。使用锁对象的notify()方法可以唤醒一个等待的线程，或者notifyAll唤醒所有等待的线程。多线程间通信用sleep很难实现，睡眠时间很难把握。

17．Lock和Condition

（1）实现提供比synchronized方法和语句可获得的更广泛的锁的操作，可支持多个相关的Condition对象

（2）Lock是个接口

（3）锁是控制多个线程对共享数据进行访问的工具。

（4）JDK1.5中提供了多线程升级的解决方案：

a.将同步synchonized替换成了显示的Lock操作，将Object中的wait、notify、notifyAll替换成了Condition对象。该对象可以Lock锁进行获取

(5)Lock的方法摘要：

a.void lock()  获取锁。

b.Condition newCondition() 返回绑定到此 Lock 实例的新 Condition 实例。

c.void unlock() 释放锁。

(6)Condition方法摘要：

a.void await() 造成当前线程在接到信号或被中断之前一直处于等待状态。

b.void signal() 唤醒一个等待线程。         

c.void signalAll() 唤醒所有等待线程。

18．停止线程：

(1)stop方法已经过时，如何停止线程？

a.停止线程的方法只有一种，就是run方法结束。如何让run方法结束呢？

b.开启多线程运行，运行代码通常是循环体，只要控制住循环，就可以让run方法结束，也就是结束线程。

(2)特殊情况：当线程属于冻结状态，就不会读取循环控制标记，则线程就不会结束。为解决该特殊情况，可引入Thread类中的Interrupt方法结束线程的冻结状态；当没有指定的方式让冻结线程恢复到运行状态时，需要对冻结进行清除，强制让线程恢复到运行状态

19.interrupt:

(1)void interrupt() 中断线程:

中断状态将被清除，它还将收到一个 InterruptedException

20.多线程join方法：

   void join() 等待该线程终止。

   void join(long millis)  等待该线程终止的时间最长为 millis 毫秒。

       throws InterruptedException        

   特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行

   作用: join可以用来临时加入线程执行；

21.多线程优先级：yield()方法

(1)yield():暂停当前正在执行的线程对象，并执行其他线程

(2)setPriority(int newPriority):更改线程优先级

(3)int getPriority() 返回线程的优先级。

(4)String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

a.MAX_PRIORITY:最高优先级(10级)

b.Min_PRIORITY:最低优先级(1级)

c.Morm_PRIORITY:默认优先级(5级)

22.什么时候抛出InvalidMonitorStateException异常?为什么？

   调用 wait ()/notify ()/notifyAll ()中的任何一个方法时，如果当前线程没有获得该对象的锁，    那么就会抛出 IllegalMonitorStateException 的异常 也就是说程序在没有执行对象的任何同步块或者同步方法时，仍然尝试调用 wait ()/notify ()/notifyAll ()时。由于该异常是 RuntimeExcpetion 的子类， 所以该异常不一定要捕获(尽管你可以捕获只要你愿意,作为RuntimeException，此类异常不会在 wait (),notify (),notifyAll ()的方法签名提及。

23.在静态方法上使用同步时会发生什么事？

同步静态方法时会获取该类的“Class”对象，所以当一个线程进入同步的静态方法中时，线程监视器获取类本身的对象锁，其它线程不能进入这个类的任何静态同步方法。它不像实例方法，因为多个线程可以同时访问不同实例同步实例方法。

24.当一个同步方法已经执行，线程能够调用对象上的非同步实例方法吗？

   可以，一个非同步方法总是可以被调用而不会有任何问题。

   实际上，Java 没有为非同步方法做任何检查，锁对象仅仅在同步方法或者同步代码块中检查。

   如果一个方法没有声明为同步，即使你在使用共享数据Java照样会调用，而不会做检查是否安全，

   所以在这种情况下要特别小心。一个方法是否声明为同步取决于临界区访问(critial section access)，

   如果方法不访问临界区(共享资源或者数据结构)就没必要声明为同步的。

25.在一个对象上两个线程可以调用两个不同的同步实例方法吗？

   不能，因为一个对象已经同步了实例方法，线程获取了对象的对象锁。

   所以只有执行完该方法释放对象锁后才能执行其它同步方法。

26.什么是线程饿死，什么是活锁？

   线程饿死和活锁虽然不像死锁一样是常见的问题，但是对于并发编程的设计者来说就像一次邂逅一样。

   当所有线程阻塞，或者由于需要的资源无效而不能处理，不存在非阻塞线程使资源可用。

   JavaAPI 中线程活锁可能发生在以下情形：

   当所有线程在程序中执行 Object.wait (0)，参数为 0 的 wait 方法。

   程序将发生活锁直到在相应的对象上有线程调用 Object.notify ()或者 Object.notifyAll ()。

   当所有线程卡在无限循环中。

 

-------android培训、java培训、期待与您交流！-------