黑马程序员——多线程

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

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

线程：就是进程中的一个独立的控制单元（执行路径，执行情景）。
  线程在控制着进程的执行。一个进程中至少有一个线程。

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

如何在程序中自定义线程呢？
     Java给我们提供了对象线程这类事物的描述。该类是Thread
该类中定义了，创建线程对象的方法(构造函数)，提供了要被线程执行的代码存储的位置（run()）
还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程：
static Thread currentThead():
String getName():
static void sleep(time)throws InterruptedException:


要运行的代码都是后期定义的。
创建线程的第一种方式是：继承Thread类。

原因：要覆盖run方法，定义线程要运行的代码。

步骤：
1，继承Thread类。
2，覆盖run方法。将线程要运行的代码定义其中。
3，创建Thread类的子类对象，其实就是在创建线程，调用start方法。

如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以在继承Thread。怎么办呢？
Java给我们提供了一个规则。Runnable接口。
如果自定义类不继承Thread，也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。
这样多线程也可以帮助该类运行。
这样的操作有一个好处：避免了单继承的局限性。

创建线程的第二种方式：实现Runnable接口。

步骤：
1，定义了实现Runnable接口。
2，覆盖接口的run方法。将多线程要运行的代码存入其中。
3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
为什么要传递？因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象
传递给Thread。让Thread线程去使用该对象调用其run方法。
4，调用Thread对象的start方法。开启线程。




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

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

两种方式区别：
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable，线程代码存在接口的子类的run方法。

线程的几种状态：

 

1，被创建。
2，运行。
3，冻结。
4，消亡。
其实还有一种特殊的状态：临时状态。
该临时状态的特点：
具备了执行资格，但不具备执行权。

冻结状态的特点：
放弃了执行资格。


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

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

问题的产生的原因：
几个关键点：
1，多线程代码中有操作共享数据。
2，多条语句操作该共享数据。
当具备两个关键点时，
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。
就会发生数据错误。

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

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

synchronized(对象)
{
需要被同步的代码

}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
示例：火车上的卫生间。

同步的表现形式：
1，同步代码块。
2，同步函数。
两者有什么不同：
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。

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

优化后的单例设计模式：

 
　双重判断

If(instance == null) { synchronized(Single.class) {         if(instance == null) { instance = new Single();           }      } } return instance; 外层if处理效率问题 内层if处理产生多个实例对象的方法。

同步的好处：

解决了线程的安全问题。

弊端：
较为消耗资源。
同步嵌套后，容易死锁。
理解死锁　

        因为线程都很执着，如果有共享资源已被占用，那么线程会一直等待下去！如果两个线程，相互想使用对方的资源，在没有得到对方资源之前，还不会释放自己的资源，这时这两个线程就都不会再向下运行，这就死锁了！

 死锁代码：

开发时一定要避免这种情况。

/*
死锁。
同步中嵌套同步。
*/
class Ticket implements Runnable
{
        private  int tick = 1000;
        Object obj = new Object();
        boolean flag = true;
        public  void run()
        {
               if(flag)
               {
                       while(true)
                       {
                               synchronized(obj)
                               {
                                      show();
                               }
                       }
               }
               else
                       while(true)
                               show();
        }
        public synchronized void show()//this
        {
               synchronized(obj)
               {
                       if(tick>0)
                       {
                               try{Thread.sleep(10);}catch(Exception e){}
                               System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
                       }
               }
        }
}
class  DeadLockDemo
{
        public static void main(String[] args) 
        {
               Ticket t = new Ticket();
 
               Thread t1 = new Thread(t);
               Thread t2 = new Thread(t);
               t1.start();
               try{Thread.sleep(10);}catch(Exception e){}
               t.flag = false;
               t2.start();
        }
}
 要记住：同步使用的前提：
1，必须是两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
这是才可以称为这些线程被同步了。

使用同步多线程解决简单的卖票问题：

class Ticket implements Runnable
{
        private  int tick = 1000;
        Object obj = new Object();
        public void run()
        {
               while(true)
               {
                       synchronized(obj)
                       {
                               if(tick>0)
                               {
                                      //try{Thread.sleep(10);}catch(Exception e){}
                                       System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
                               }
                       }
               }
        }
}
class  TicketDemo2
{   
        public static void main(String[] args) 
        {      Ticket t = new Ticket();
 
               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();
        }
}

终止线程：
1　stop()方法

用来终止线程，但这个方法已经作废了。它很可能会造成死锁！

我们不应该使用它！
2　使用interrupt()方法

　　把该线程的中断状态修改为true
3　isInterrupted()方法和interrupted()的作用

isInterrupted()获取当前线程的中断状态，并把中断状态修改为false。该方法是static方法

interrupted()获取当前线程的中断状态，它不会修改中断状态。

4　中断异常相关方法

join()   当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。但我测试的时候好像jion方法加入的线程总体会先执行，但还是有被其他线程抢夺的可能，不知道怎么回事。它可以用来临时加入线程执行。

sleep() – 静态的

wait() – Object类的。

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

线程间通讯方法有：
　　wait()、notify()、notifyAll()