黑马程序员_多线程

多线程

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

进程：正在执行中的程序（直译），一个运行的进程就是在内存中开辟空间。

线程：就是进程中一个负责程序执行的控制单元（执行路径），

一个进程中可以有多个执行路径，也称多线程

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

开启多个线程是为同时运行多部分代码，每个线程都有自己运行的内容，这个内容可以称为线程要执行的任务。

多线程的好处：解决了多部分同时运行的问题

弊端：线程太多会导致效率降低。

其实应用程序的执行都是cpu在做着快速的切换完成的，这个切换是随机的。

JVM启动时就启动了多个线程，至少有两个线程可以分析的出来，

1.       执行Main函数的线程，

该线程的任务代码都定义在main函数中。

2.       负责垃圾回收的线程。

如何创建一个线程

方式1.继承Thread类

步骤：

1.       对应一个类继承Thread类，

2.       覆盖Thread中的run方法。

3.       创建线程对象，也就是Thread子类对象。

4.       调用start方法开启线程并调用线程的任务run方法执行。

例子：

创建线程的目的是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。

而运行的指定代码就是这个执行路径的任务，

JVM创建的主线程的任务都定义在了主函数中，

而自定义的线程他的任务在哪儿呢？

Thread类用于描述线程，线程是需要任务的，所以Thread类也对任务的描述。

这个任务就通过Thread类中的run方法来体现，也就是说，run方法就是封装自定义线程。

Run方法中定义的就是线程要运行的任务代码。Run方法是封装线程任务的。

开启线程是为了运行指定代码，所有只有继承Thread类，并复写run方法，将运行的代码定义在run方法中即可。

可以通过父类的getName方法可以得到线程的名称。

调用start和调用run方法的区别

   调用start方法是启动线程，多个任务执行run方法中的代码，而调用run方法只是在主线程执行，只是单线程在执行。

Cpu的执行资格：可以被cpu的处理，在处理队列中排队

Cpu的执行权：正在被cpu的处理

多线程的状态：

创建线程的第二种方式，：实现runnable接口

1.       定义类实现runnable接口

2.       覆盖接口中的runf方法，将线程的任务代码封装到run方法中。

3.       通过thread类创建线程对象，并将runnable接口的子类对象作为thread类的构造函数的参数进行传递

为什么?因为线程的任务都封装在runnabble接口子类对象的run方法中。

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

4.       调用线程对象的start方法开启线程

例子：

实现runnable接口好处

1.       将线程的任务从线程的子类中分离出来，进行了单独的封装。

按照面向对象的思想讲任务的封装成对象。

2.       避免了java单继承的局限性。

所以创建线程的第二种番薯较为常用。

线程安全问题产生的原因：

1.       多个线程在操作共享的数据。

2.       操作共享数据的线程代码有多条。

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算。

就会导致线程安全问题的产生。

解决思路：

就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程是不可以参与运算的，

必须要当前线程把这些代码都执行完之后，其他线程才可以参与运算。

在Java中，用同步代码块就可以解决这个问题。

同步代码块的格式：

Synchronized(对象)

{

       需要被同步的代码；

}

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

同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

同步函数的使用的锁是this;

同步函数和同步代码块的区别：

1.       同步代码块的锁是任意的对象。

建议使用同步代码块。

静态的同步函数使用的锁是该函数所属字节码文件对象，可以用getClass方法获取，也可以用当前类名.class表示。

//在线程中饿汉式

class Single

{

       private static final Single s=new Single();

       private Single(){}

       public static Single getInstance()

       {

              return s;

       }

}

如果在多线程中都共享着s数据，不管调用getInstance多少次。都是返回一个对象，因为s已被final修饰，所以永远都只是一个对象被返回。

//在线程中懒汉式

class Single

{

       private static Single s=null;

       private Single(){}

       public static Single getInstance()

       {

              if(s==null)

              {

                     synchronized(Single.class)

                     {

                            if(s==null)

                            s=new Single();

                     }

              }

              return s;

       }

}

 

加入同步为了解决多线程安全问题

加入双重判断是为了效率问题。

死锁

同步的嵌套容易导致死锁。

例子：

Synchronized(对象)

{

Synchronized(对象)

{

}

}

线程通信

多个线程在处理统一资源，但是任务却不同。

等待唤醒机制

1.       wait():让线程处于冻结状态，被wait的线程会被存储在线程池中。

2.       notify():唤醒线程池中一个线程（任意）

3.       notiyfAll():唤醒线程池中所以的线程。

这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法wait notify notifyAll定义在了object类中。

因为这些方法是监视器的方法，监视器其实就是锁，锁可以使人一定对象，任意的对象调用的方式一定定义在Object类中。

If判断标记，只有一次，会导致bugatti运行的线程运行了，出现了数据错误的情况。

While判断标记，解决了线程获取执行权后，是否要运行。

Notify：只能欢喜一个线程，如果本方欢喜了本方，没有意义，而且while判断判断标记notify会导致死锁。

notifyAll解决了本方线程一定会唤醒对方线程

同步代码块，对于锁的操作时隐式的。

Jdk1.5以后将同步和锁封装成了对象，并将操作锁的隐式方式定义到对象中，将隐式动作变成了显示动作。

Lock接口：出现代替了同步代码块或者同步函数，讲同步的隐式锁草组变成显示锁操作，同时更为灵活，可以一个锁上加上多组监视器。

Lock():获取锁

Unlock();释放锁，通常需要定义finally代码块中。

Condition接口：出现代替了object中的wait notiry notifAll方法，将这些监视器方法单独进行了封装，变成condition

Wait和sleep的区别？

1.       wait可以指定时间也可以不指定

sleep必须指定时间

2.       在同步中是，对于CPU的执行权和锁的处理不同。

Wait:释放执行权，释放锁

Sleep:释放执行权，不释放锁。

停止线程：

1.       stop方法

2.       run方法结束

怎么看着线程的任务结束呢？

任务中都会有循环结构，只要控制住循环，就可以结束任务。

看着循环通常就用定义标记来完成，

如果线程处于了冻结状态，无法读取标记，如何结束呢？

可以使用interrupt方法将线程从冻结状态强者恢复到运行状态中来，让线程被CPU的执行资格。当时强制动作会发生了interrupterException,记得要处理。

 

---------------------- android培训、java培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net/heima