黑马程序员_多线程（1）

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

多线程：

1、进程和线程：

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

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

       两者的区别：

              一个进程至少有一个线程

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

      

2、多线程的优势：

       解决了多部分同时运行的问题，提高效率

 

3、线程的弊端：

       线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。

 

4、什么叫多线程：

       一个进程中有多个线程，称为多线程。

 

5、实现多线程的方法：

       实现多线程可以通过继承Thread类和实现Runnable接口。

       (1)继承Thread

           定义一个类继承Thread类

           复写Thread类中的public voidrun()方法，将线程的任务代码封装到run方法中

           直接创建Thread的子类对象，创建线程

           调用start()方法，开启线程(调用线程的任务run方法)

           //另外可以通过Thread的getName()获取线程的名称。

 

       (2)实现Runnable接口；

              定义一个类，实现Runnable接口；

              覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；

              创建Runnable接口的子类对象

              将Runnabl接口的子类对象作为参数传递给Thread类的构造函数，创建Thread类对象

                       （原因：线程的任务都封装在Runnable接口子类对象的run方法中。

                       所以要在线程对象创建时就必须明确要运行的任务）。

              调用start()方法，启动线程。

      

       两种方法区别：

              (1)实现Runnable接口避免了单继承的局限性

              (2)继承Thread类线程代码存放在Thread子类的run方法中

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

                 在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现

 

6、创建线程是为什么要复写run方法？

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

 

7、start()和run方法有什么区别？

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

       Start()方法:

              start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的

              代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，

              一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，

              它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。      

       Run()方法:

              run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,

              其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，

              这样就没有达到多线程的目的。

 

8、线程的几种状态：

       新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个时候，

             只是对象线程对象开辟了内存空间和初始化数据。           

       就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。

             在这个状态的线程对象，具有执行资格，没有执行权。

       运行：当线程对象获取到了CPU的资源。

             在这个状态的线程对象，既有执行资格，也有执行权。

       冻结：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。

              当然，他们可以回到运行状态。只不过，不是直接回到。

             而是先回到就绪状态。

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

 

9、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可以在任何地方使用

 

10、多线程安全问题：

       (1)原因:当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性导致

               一个线程对多条语句，执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，

               此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。      

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

 

11、Java中多线程同步是什么？

        同步是用来解决多线程的安全问题的，在多线程中，同步能控制对共享数据的访问。如果没有同步，当一个线程在

        修改一个共享数据时，而另外一个线程正在使用或者更新同一个共享数据，这样容易导致程序出现错误的结果。

 

12、什么是锁?锁的作用是什么?

       锁就是对象

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

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

 

13、同步的前提:

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

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

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

 

14、同步的好处和弊端

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

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

 

15、同步的两种表现形式：

       (1)同步代码块: Synchronized（对象）｛需要被同步的代码｝

              可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象

              考虑到安全问题，一般还是使用同一个对象，相对来说效率较高。

 

              注意：

              **虽然同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，

                必须保证同步代码快的锁的对象和，否则会报错。

              **同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是

                同一个对象，也就是都是this锁代表的对象。

       (2)同步函数：修饰词 synchronized 返回值类型 函数名(参数列表){需同步的代码;}

 

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

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

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

 

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

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

 

16、死锁

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

死锁问题：我拿着锁想去你那，你也拿着锁你却想来我这。

代码：【背会，面试：写出一个死锁程序。会了那么就会避免死锁，需要对同步很熟悉】

class Test{

private booleanflag;

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{

while(true){

synchronized(MyLock.lockb){

System.out.println(“if  lockb”);

synchronized(MyLock.locka){

System.out.println(“if  locka”);

}

}

}

}

}

}

 

Class MyLock{

syatic ObjeckLocka = new Obeck();

syatic ObjeckLockab= new Obeck();

}

Class DeaadLockTest{

Public staticvoid main(String[] args){

Thread t1= new Thread(new Test(true));

Thread ti2= new Thread(new Test(false));

t1.start();

t2.start();

}

}

 

 

17、Lock和Condition

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

       Lock是个接口

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

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

       将同步synchonized替换成了显示的Lock操作，将Object中的wait、notify、notifyAll替换成了Condition对象。

       该对象可以Lock锁进行获取

 

       Lock的方法摘要：

              voidlock()  获取锁。

              ConditionnewCondition() 返回绑定到此 Lock 实例的新 Condition 实例。

              voidunlock() 释放锁。

       Condition方法摘要：

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

              voidsignal() 唤醒一个等待线程。         

              voidsignalAll() 唤醒所有等待线程。