黑马程序员_java_多线程



------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

多线程：

进程：一个正在执行的程序，
 每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者是执行单元。
线程：进程中一个独立的控制单元。
 一个进程至少有一个线程。
定义方式：
 第一种：定义类继承于Thread类，复写run方法;
 第二种：实现Runnable接口。复写run()方法

实现接口 Runnable：
 步骤：
  1，定义类实现Runnable接口
  2，覆盖Runnable接口中的run方法
   将线程代码放在run方法中。
  3，通过Thread类建立线程对象。
  4，将Runnabla接口中的子类对象作为实际参数传给Thread类的构造函数。
   因为自定义run方法所属对象是Runnable接口的子类对象，所以要让线程去指定对象的run方法，就必须明确run方   法的所属对象

  5，调用Thread类的start方法开启并调用Runnable接口子类中的run方法。
实现和继承的区别：
 实现方式：避免的单继承的局限性。（建议使用实现Runnable接口方式）
 继承Thread:线程代码存放于Thread类的run方法中。
 实现Runnable:线程代码存放于接口子类分run方法中。
同步代码块：

 synchroized(对象){//Object obj = new  Objece();
  同步代码
 }
同步的前提：
  1，必须要有两个或者俩个以上的线程。
  2，必须要多个线程使用同一个锁。
好处：解决多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。
同步函数：把synchronized 作为修饰符放在函数上。
静态函数：静态同步函数的的锁是该方法所在类的字节码文件对象：类名.class

死锁：

/*
 死锁

*/
class Lack implements Runnable
{ 
 Object lacka = new Object();
 Object lackb = new Object();
 private boolean flag;
 public  Lack(boolean flag)
 {
  this.flag= flag;
 }
 public void run()
 {
  if(flag)
  {
   while(true)
   {
    synchronized(lacka)
    {
     System.out.println("if lacka");
     synchronized(lackb)
     {
      System.out.println("if lackb");
     }
    }
   }
  }
  else
  {
   while(true)
   {
    
    synchronized(lackb)
    {
     System.out.println("else lackb");
     synchronized(lacka)
     {
      System.out.println("else lacka");
     }
    }
   }
  }
 } 
}

class MyLack
{
 public static void main(String[] args)
 { 
  Thread t1 = new Thread(new Test(true));
  Thread t2 = new Thread(new Test(true));
  t1.start();
  t2.start();
 }
}

面试常考：懒汉式 单例设计模式

/*
懒汉式单例设计模式
*/

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;
 }
}

 
编程代码：售票。
 
class Ticket implements Runnable //extends Thread
{
 private int tick =100;
 public void run(){
  if(tick >0){
   while(true){
    System.out.println(Thread.currentThread().getName()+tick--);

   }
  }
 }
}

class TicketDemo
{
 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);
  //Ticket t1 = new Ticket();
  //Ticket t2 = new Ticket();
  //Ticket t3 = new Ticket();
  //Ticket t4 = new Ticket();
   t1.start();
   t2.start();
   t3.start();
   t4.start();
 }
}

/*
 生产者  消费者。
*/

public class ProducerDemo
{
 public static void main(String[] args)
 {
  Resource r   = new Resource();
  Consumer con = new Consumer(r);
  Producer pro = new Producer(r);
  Thread t1 = new Thread(con);
  Thread t2 = new Thread(pro);
  Thread t3 = new Thread(con);
  Thread t4 = new Thread(pro);
  t1.start();
  t2.start();
  t3.start();
  t3.start();
 }
}

class Resource
{

 private String name;
 private int count = 1;
 private boolean flag = false;
  
 public synchronized void set(String name)
 {
  while(flag)
  {
   
    try
    {
     this.wait();
     
    }
    catch (Exception e)
    {
    }
  }  this.name = name+"..."+count++;
    System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
    flag =true;
    this.notifyAll();
   
 }

 public synchronized void get()
 {
  while(!flag)
  {
   
    try
    {
     this.wait();
    }
    catch (Exception e)
    {
    }
  }
    System.out.println(Thread.currentThread().getName()+"---消费者---"+this.name);
    flag = false;
    this.notifyAll();
   
 }
}

class Consumer implements Runnable
{
 private Resource res;
 public Consumer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  while(true)
  {
   res.get();
  }
  
 }
}

class Producer implements Runnable
{

 private Resource res;
 public Producer(Resource res)
 {
  this.res = res;
 }

 public void run()
 {
  while(true)
  {
   res.set("商品");
  }
 }
}