黑马程序员_多线程与死锁

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

 

一、线程的创建

1、继承Thread类

创建步骤：
1、定义类继承Thread
2、复写Thread类中的run方法
3、调用线程的start方法
此方法有两个作用：
启动线程
调用run()方法

 class Demo extends Thread//定义类继承Thread
{
 public void run()//复写run()方法
 {
  for(int x=0; x<60; x++)
   System.out.println("Demo run()---"+x);
 }
}
class  ThreadDemo
{
 public static void main(String[] args) 
 {
  Demo d = new Demo();//创建一个线程
  d.start();//开启线程，并调用线程的run()方法
  for(int x=0; x<60; x++)
   System.out.println("Hello Thread!---"+x);
 }
}

程序运行结果如下：

 
运行结果每一次都不同。

因为多个下次都要获取CPU的执行权，CPU执行到谁，谁就运行。

但是在某一时刻，只能有一个程序在运行。（多核除外）

多线程的一个特性，随机性。

2、实现Runnable接口

/*
需求：简单的卖票程序，多个窗口同是卖票。
创建线程的第二种方式：实现Runnable接口
步骤：
1、定义类实现Runnable接口
2、覆盖Runnable接口中的run方法。
 将线程要运行的代码存放在该run方法中。
3、通过Thread类建立线程对象。
4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

*/
class Ticket implements Runnable
{
 
 private int tick = 100;
 public void run()
 {
  while (true)
  {
   if(tick>0)
   {
    System.out.println(Thread.currentThread().getName()+"---sale  : "+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);
  
  t1.start();
  t2.start();
  t3.start();
  t4.start();
 }
}
 

程序运行结果如下：

3、两种方法对比

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

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

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

二、多线程的安全问题

1、通过分析上述程序，发现存在安全隐患，可以通过代码进行验证。

class Ticket implements Runnable 
{
 
 private int tick = 100;
 public synchronized void run() 
 {
  while (true)
  {
   if(tick>0)
   {
    //因为继承了接口，而接口中没有异常的抛出，所以只能try
    try{Thread.sleep(10);}catch(Exception e){}
    System.out.println(Thread.currentThread().getName()+"---sale  : "+tick--);
   }
  }
 }
}  
 

修改后运行结果出现以下情况：

              
              

               
               
              
              
              
              
 
              
              
              
              

               
               出现问题原因：
              
              
              
              

               
                  当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还未执行完，另一个线程就进入执行，从而导致共享数据出错。
              
              
              
              

               
               
 2、JAVA对多线程安全问题有专业解决方式：同步代码块。
synchronized(对象)
{
 需要被同步的代码
}
              
              

具体代码如下：

 

 class Ticket implements Runnable 
{
 //Object obj = new Object();
 
 private int tick = 1000;
 public void run() 
 {
  while (true)
  {
   synchronized(this)
   {
    if(tick>0)
    {
     //因为继承了接口，而接口中没有异常的抛出，所以只能try
     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);
  Thread t5 = new Thread(t);
  
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  t5.start();
  
 }
}

代码修改后，运行结果中未出现为0等错误情况。

好像是CPU的缘故，在票数1000的时候，只能看到一个线程。当票数为10000的时候，方可看到其他线程运行的情况。

 

3、单例设计模式

 

/*
单例设计模式
 
*/
//饿汗式
class Single
{
 private static final Single s = new Single();
 private Single(){}
 public static Single getInstance()
 {
  return s;
 }
}
 
//懒汉式
//延迟加载单例模式
class Single
{
 private static Single s = null;
 private Single(){}
 public static Single getInstance()
 {
  synchronized(Single.class)//通过锁确保程序在多线程访问时运行安全
  {
   if(s==null)
    s = new Single();
  }
  return s;
 }
}  
 

发现懒汉式中，如果有一个线程进入锁中，其它线程只能等待，会导致程序效率低，继续对其进行完善。

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 Test implements Runnable
{
 private boolean flag;
 Test(boolean flag)//建立标识，让两个线程分别运行。
 {
  this.flag = flag;
 }
 public void run()//锁相互嵌套，形成各自占用资源，同时需要对方资源。
 {
  if (flag)
  {
   synchronized(MyLock.LockA)
   {
    System.out.println("if LockA");
    synchronized(MyLock.LockB)
    {
     System.out.println("if LockB");
    }
   }
  }
  else
  {
   synchronized(MyLock.LockB)
   {
    System.out.println("else LockB");
    synchronized(MyLock.LockA)
    {
     System.out.println("else LockA");
    }
   }
  }
 }
}
class MyLock//创建两个锁
{
 static Object LockA = new Object();
 static Object LockB = new Object();
}
class DeadLockDemo
{
 public static void main(String[] args)
 {
  Thread t1 = new Thread(new Test(true));//创建线程t1
  Thread t2 = new Thread(new Test(false));//创建线程t2
  t1.start();
  t2.start();
 }
} 
程序运行结果如下：
               
               

                
                
               
               
               
               

                
                可见：两个线程分别只运行了第一输出语句，便形成了死锁。
               
               
 

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

详细请查看：http://edu.csdn.net/heima/