黑马程序员_java基础部分_线程

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

线程的总结

1.         线程，进程的概念；

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

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

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

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

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

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

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

该线程称之为主线程。

2.         创建线程的两种方式：

一、第一种方式，继承Thread类。

步骤：

1，定义类继承Thread。

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

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

3，调用线程的start方法，

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

Thread类用于描述线程。

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

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

二、创建线程的第二种方式：实现Runable接口

步骤：

 1，定义类实现Runnable接口

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

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

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

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

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

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

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

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

 实现方式和继承方式有什么区别呢？

 实现方式好处：避免了单继承的局限性。

 在定义线程时，建立使用实现方式。

 两种方式区别：

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

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

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

4.         创建子类对象给线程的代码；

public static void main(String[] args) {

// 创建一个runnable对象，可以启动n个线程；

Ticket03 t = new Ticket03();

//传递给n个线程的构造函数；

Thread t1 = new Thread(t);// 创建了一个线程；

Thread t2 = new Thread(t);// 创建了一个线程；

Thread t3 = new Thread(t);// 创建了一个线程；

Thread t4 = new Thread(t);// 创建了一个线程；

t1.start();

t2.start();

t3.start();

t4.start();

5.         同步代码块；解决了线程的安全问题；

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

就是同步代码块。

//对象可以是任意对象；我们一般选择Object，也可以是字节码对象；

Object obj = new Object();

synchronized(对象)

{

         需要被同步的代码

}

     同步的前提：

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

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

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

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

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

6.         死锁；

同步中嵌套同步。

函数中有同步代码块，

同步代码块中有函数；

就会出现死锁的情况         

7.         目的：该程序是否有安全问题，如果有，如何解决？

如何找问题：

1，明确哪些代码是多线程运行代码。

2，明确共享数据，  b和sum

3，明确多线程运行代码中哪些语句是操作共享数据的。

这里讲解的是同步函数的写法；

public synchronized void add(int n)

{

synchronized(obj)

//{

//这个里面是把sum给分开了，所以这里会出现问题；

sum = sum + n;

try{Thread.sleep(10);}catch(Exception e){}

System.out.println("sum="+sum);

//}

}

 

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

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

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

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

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

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

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

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

10.     线程间通讯：

其实就是多个线程在操作同一个资源，但是操作的动作不同

wait:

notify();

notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作。

所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程的锁，

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

11.     线程中的run方法；判断标记；

public void run()

{

while(true)

{

synchronized(r)

{

flag刚开始为真；后来运行一下为假，假的时候等待；

if(!r.flag)

try{r.wait();}catch(Exception e){}

System.out.println(r.name+"...."+r.sex);

r.flag = false;

r.notify();

这里本线程继续执行；

}

12.     对于多个生产者和消费者。

为什么要定义while判断标记。

原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，

因为需要唤醒对方线程。

因为只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。

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

 

将同步Synchronized替换成显示的Lock操作。

将Object中的wait，notify notifyAll，替换了Condition对象。

该对象可以Lock锁进行获取。

该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized

                                                       lock

                                                       unlock

                                                       newCondition()   得到Condition对象；

Condition：替代了Object wait notify notifyAll

                                                       await();       wait

                                                       signal()       notify

                                                       signalAll();    notifyAll

新技术获取多个Condition对象                                                                                                  //  t1    t2

//因为他是接口，所以用子类去获取锁的对象；

private Lock lock = new ReentrantLock();

//  获取锁对象；这个是新特性很牛的功能；  一个锁可以绑定好多Condition对象；

private Condition condition_pro = lock.newCondition();

private Condition condition_con = lock.newCondition();

14.     stop方法已经过时。

如何停止线程？

只有一种，run方法结束。

开启多线程运行，运行代码通常是循环结构。

只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：

当线程处于了冻结状态。

就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态是，这时需要对冻结进行清除。

强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread类提供该方法 interrupt();

15.     join:

当A线程执行到了B线程的.join()方法时，A就会等待，等B线程都执行完，A才会执行。

join可以用来临时加入线程执行。

t1.join();申请加入到运行中来，t1要cpu执行权；它先执行；

主线程等待它执行完了，才能继续执行；

t1.join();它前面的线程都可以执行，它前面只有它自己那就它自己执行；

 

16.     临时停止；释放执行权；减缓线程执行的频率；

Thread.yield();

17.      守护线程，或者用户线程；                                                                                                                      

后台线程；特点；开启和运行一样跟cpu一起运行，

但是后台线程有个特点，其他的所有前台线程结束之后，它就自动结束了；

使用方法；必须在线程启动前运行；

t1.setDaemon(true);

t2.setDaemon(true);

18.     多线程的总结

一、多线程具备随机性，因为是由cpu不断的快速切换造成的。

就有可能会产生多线程的安全问题。

问题的产生的原因：

几个关键点：

1，多线程代码中有操作共享数据。

2，多条语句操作该共享数据。

当具备两个关键点时，

有一个线程对多条操作共享数据的代码执行的一部分，还没有执行完，另一个线程开始参与执行。

就会发生数据错误。

解决方法：

当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。

Java就对这种解决方式提供了专业的代码。

二、同步

同步的原理：就是将部分操作功能数据的代码进行加锁。

同步的表现形式：

1，同步代码块。

2，同步函数。

两者有什么不同：

同步代码块使用的锁是任意对象。

同步函数使用的锁是this。

注意：对于static的同步函数，使用的锁不是this。是类名.class 是该类的字节码文件对象，涉及到了单例设计模式的懒汉式。

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

弊端：

                             较为消耗资源。

                             同步嵌套后，容易死锁。

 

要记住：同步使用的前提：

                             1，必须是两个或者两个以上的线程。

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

                             这是才可以称为这些线程被同步了。

死锁代码一定会写。但开发时一定注意避免