黑马程序员_多线程

多线程

线程：一个正在执行的程序。

多线程存在的意义： 
程序运行中至少有两个线程在运行，一个是主函数的主线程，另一个是垃圾回收的线程。
线程创建方式一：
继承Thread类.要覆盖其run方法，调用线程的start方法.

作用：

1.启动线程

2.运行run方法。目的是将自定义的代码存储在run方法中,让线程运行
cpu每次只执行一个程序，只是在快速的不同线程间切换，表现了多线程的随机性


class demo extends Thread{
  public void run(){
  }
}


run方法用于存储线程要运行的代码。


demo demo=new demo();创建对象就创建了一个线程。


run方法和 start方法的区别


run方法  仅仅是对象调用方法，并没有运行线程

start方法  是开启线程并且执行线程中的run方法

创建线程的第二种方式：

实现Runnable接口。


创建线程 


Thread t=new Thread(new 对象名());


步骤：
1，定义类实现Runnable接口。
2，覆盖接口中的run方法（用于封装线程要运行的代码）。
3，通过Thread类创建线程对象；
4，将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
      为什么要传递呢？因为要让线程对象明确要运行的run方法所属的对象。
5，调用Thread对象的start方法。开启线程，并运行Runnable接口子类中的run方法。
Ticket t=new Ticket();
/*
直接创建Ticket对象，并不是创建线程对象。
因为创建对象只能通过newThread类，或者new Thread类的子类才可以。所以最终想要创建线程。既然没有了Thread类的子类，就只能用Thread类。*/
Thread t1=new Thread(t);//创建线程。/*
只要将t作为Thread类的构造函数的实际参数传入即可完成线程对象和t之间的关联
为什么要将t传给Thread类的构造函数呢？其实就是为了明确线程要运行的代码run方法。*/


实现方式和继承方式有什么区别？
继承Thread类：线程代码块存放在Thread子类的run方法中
实现Runnable，线程代码存放在接口的子类的run方法中，可以被多实现。


继承方式有局限性。

要被实现多线程的一个类 如果继承了父类 就不能再继承Thread类。
实现方式就变面了单继承的局限性。

线程运行状态

新建：start()
运行：具备执行资格，同时具备执行权；
冻结：sleep(time),wait()—notify()唤醒； 线程释放了执行权，同时释放执行资格；
临时阻塞状态：线程具备cpu的执行资格，没有cpu的执行权；
消亡：stop() run方法结束

多线程安全：
安全产生的原因：当多条语句在操作同一个共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行。导致共享数据的错误。


解决办法：
队多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。


方式：同步代码块：
synchronized(对象)，火车卫生间案例  
{
  需要被同步的代码。（共享数据）
}


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


同步的前提：
1.必须要有两个或者两个以上的线程
2.必须多个线程必须使用同一个锁。
  必须保证同步中只能有一个线程在运行。


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

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

死锁：
同步中嵌套同步，可能会发生，该怎么解决


死锁是由于 两个线程相互等待 对方已被锁定的资源


循环等待条件：第一个线程等待其它线程，后者又在等待第一个线程。


避免死锁的一个通用的经验法则是:当几个线程都要访问共享资源A、B、C时，
保证使每个线程都按照同样的顺序去访问它们，比如都先访问A，在访问B和C。 

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


1.是不是两个或两个以上的线程。解决办法 两个线程都要被同步。
2.是不是同一个锁。解决办法 找同一个对象作为锁。

线程间通信：

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

1.是不是两个或两个以上的线程。

解决办法 两个线程都要被同步。
2.是不是同一个锁。

解决办法 找同一个对象作为锁。

等待唤醒机制。


wait后，线程就会存在线程池中，notify后就会将线程池中的线程唤醒。
notifyAll();唤醒线程池中所有的线程。
实现方法 ：


给资源加个标记 flag   


synchronized(r)
{
 while(r.flag)//多个生产者和消费者   if(r.flag)//一个生产者和消费者
  r.wait();
  代码
   r.flag=true;
  r.notify();
  r.notifyAll();
}


上面三种方法都使用在同步中，因为要对持有监视器（锁）的线程操作。所以要使用在同步中，因为只有同步才具有锁。


注意：为什么这些操作线程的方法要定义在object类中呢？
因为这些方法在操作同步中线程的是偶，都必须要表示它们所操作线程只有的锁。只有同一个锁上的被等待线程，可以被
同一个锁上的notify唤醒，不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁，而锁可以是特意对象，可以被任意对象调用的方法定义在Object类中。

多生产者和消费者 JDK1.5版本升级版。
Lock接口    
 Lock 替代了synchronized 
 Condition 替代了 Object监视器方法


好处：将同步synchronized 替换成了 Lock
      将object中的wait notify notifyAll 替换成了 Condition对象
      该对象可以Lock锁进行获取。一个锁可以对应多个Condition对象
注意：释放锁的工作一定要执行
。
示例代码


private Lock lock=new ReentrantLock();
private Condition condition =lock.newCondition();


public void cet(String name ) throws 
{
   lock.lock();
   try
   {
      while(flag)
           contidition.await();
       this.name=name+"--"+count++;


       sop(Thread.currentThread().getName()+"...生产者..."+this.name)
       flag=true；
        condition.signalAll();


    }
    finally
    {
       lock.unlock();
         
   }
}

停止线程：


run方法结束，就会停止线程，开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让线程结束。


方法：改变标记。




特殊情况，改变标记也不会停止的情况。


将处于冻结状态的线程恢复到运行状态。interrupt();  中断线程。


守护线程：
SetDaemon将线程标记为守护线程或用户线程。在启动线程前调用 。当线程都为守护线程后，JVM退出。


JOin方法：


t.join();抢过cpu执行权。


当A线程执行到了B线程的join方法时，A就会等待，等B线程执行完，A才会执行。Join可以用来临时加入线程执行。


优先级：
SetPriority(1-10)设置优先级。
Thread.MAX_PRIORITY 10
Thread.MIN_PRIORITY 1
Thread.NORM_PRIORITY 5


yield方法：暂停当前正在执行的线程对象，并执行其他线程。


开发中应用：：保证以下三个代码同时运行。




案例




new Thread()
{
      for(int x=0;x<100;x++)
      {
         sop(Thread.currentThread().getName())


       }
}.start();




 for(int x=0;x<100;x++)
{
   sop(Thread.currentThread().getName())


}


Runnable r=new Runnable()
{
   public voud run(){
     for(int x=0;x<100;x++)
     {
      sop(Thread.currentThread().getName())


     }


    }
};


new Thread(r).start();

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