黑马程序员——线程及通信机制

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

          昨天把多线程和以及通信唤醒机制复习了一遍。总结了一下，么来得及发博客，今天发了吧，里边有自己总结的，也有毕老师上课讲的。差不多涵盖了多线程同步的比较重要的知识点吧，欢迎拍砖，指正！

多线程：

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

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

创建线程有两种方式：

第一种方式：继承Thread类。

1，定义类继承Thread。

2，复写Thread类中的run方法。目的：将自定义代码存储在run方法。让线程运行。

      public void run(){     覆盖run方法}

3，调用线程的start方法，

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

start()和run()的区别：

Demo d = new Demo();创建好一个线程。

            d.start();开启线程并执行该线程的run方法。

           d.run();仅仅是对象调用方法。而线程创建了，并没有运行。

第二种方式：实现Runable接口

1，定义类实现Runnable接口

2，覆盖Runnable接口中的run方法。将线程要运行的代码存放在该run方法中。

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

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

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

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

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

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

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

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

多线程的运行容易出现安全问题

InputOutput的模式：

class Res{ booleanflag = false;}创建资源类

class Input implements Runnable{}创建输入类实现Runnable接口

class Output implements Runnable{}创建输出类实现Runnable接口

public static void main(String[] args)

      {

           Res r = new Res();  资源对象

           Input in = new Input(r);   资源对象作为实际参数传递给input的构造函数

           Output out = new Output(r); 资源对象作为实际参数传递给output的构造函数

           Thread t1 = new Thread(in); 通过Thread类建立线程对象，将Runnable接口的输入子类对象作为实际参数传递给Thread类的构造函数。

Thread t2 = new Thread(out);通过Thread类建立线程对象，将Runnable接口的输出子类对象作为实际参数传递给Thread类的构造函数。

            t1.start();

            t2.start();

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

}

同步：

同步代码块

synchronized(对象)

{

                 需要被同步的代码

}

对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

同步的前提：

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

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

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

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

 

Object obj = newObject();

            synchronized(obj)同步代码块的所可以是任意对象，一般用Object

                 {

                 }

publicsynchronized void show()同步函数的锁是this

      {

      }

这里提到一个毕老师强调的面试经常会问的问题：在单例设计模式中懒汉式和饿汉式的区别是什么？

      懒汉式用于实例的延迟加载。

加载有没有问题？

      有，如果遇到多线程，会出现安全问题。

能不能解决？

      能，可以用同步来解决，加同步的方式，同步代码块和同步函数都行，但效率会稍低。用双重判断形势能解决效率的问题。

那么加同步的锁是哪个？

      该类所属的字节码文件对象。

延迟加载的单例设计模式。

class Single

{

      private static Single s = null;

      private Single(){}

      public static Single getInstance()//当多条线程访问它

      {

           if (s==null)//减少判断锁的次数

           {

                 synchronized(Single.class)//静态里边没有this。他的是该类所属的字节码文件对象。

                 {

                      if(s==null)

                      {

                             s = new Single();//对象被延迟加载

                      }

                 }

           }

           return s;

      }

}

线程间通信：

      等待/唤醒机制。

JDK1.5 中提供了多线程升级解决方案。将同步Synchronized替换成现实Lock操作。将Object中的wait，notify notifyAll，替换了Condition对象。该对象可以Lock锁进行获取。该示例中，实现了本方只唤醒对方操作。

Lock:替代了Synchronized

      lock

      unlock

      newCondition()

Condition：替代了Object wait notify notifyAll

      await();

      signal();

      signalAll();

现在是将wait，notify等方法，封装进一个特有的对象Condition，而一个Lock锁上可以有多个Condition对象。

      Lock lock = new ReentrantLock();

      Condition conA = lock.newCondition();

      Condition conB = lock.newCondition();

生产者线程

      {

           if(flag)

conA.await();生产者的锁

           flag = true;

           conB.signal()消费者的锁只能唤醒消费者

      }

消费者的线程    

      {

           if(!flag)

           conB.await();消费者的锁

           flag = false;

           conA.signal();生产者的锁只能唤醒生产者

      }

 

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