黑马程序员_多线程

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

 

           多线程

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

如何在自定义的代码中，自定义一个线程呢？
 通过对api的查找，java已经提供了对线程这类事物的描述。就Thread类。
 创建线程的第一种方式：继承Thread类。
步骤1:
 1，定义类继承Thread。
 2，复写Thread类中的run方法。
  目的：将自定义代码存储在run方法。让线程运行。
 3，调用线程的start方法，
  该方法两个作用：启动线程，调用run方法。
步骤2:
 实现Runable接口
 步骤：
 1，定义类实现Runnable接口
 2，覆盖Runnable接口中的run方法。
  将线程要运行的代码存放在该run方法中。
 3，通过Thread类建立线程对象。
 4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
  为什么要将Runnable接口的子类对象传递给Thread的构造函数。
  因为，自定义的run方法所属的对象是Runnable接口的子类对象。
  所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。
 5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。
 实现方式和继承方式有什么区别呢？
 实现方式好处：避免了单继承的局限性。
 在定义线程时，建立使用实现方式。 

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

为什么要覆盖run方法呢？
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码。

 Thread currentThread():获取当前线程对象。
 getName(): 获取线程名称。

同步:
 对象如同锁。持有锁的线程可以在同步中执行。
 没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
 同步的前提：
 1，必须要有两个或者两个以上的线程。
 2，必须是多个线程使用同一个锁。
 必须保证同步中只能有一个线程在运行。
 好处：解决了多线程的安全问题。
 弊端：多个线程需要判断锁，较为消耗资源，
同步的两种表现形式:
 同步代码块。
  synchronized(对象)
  {
   需要被同步的代码
  }

 

同步函数:
 格式：在函数上加上synchronized修饰符即可。
 同步函数用的是哪一个锁呢？
  函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
  所以同步函数使用的锁是this。
 如果同步函数被静态修饰后，使用的锁是什么呢？
  静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。
  类名.class  该对象的类型是Class
  静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class

 

死锁:

同步中嵌套同步.但是锁却不同.就会产生死锁.
一些线程的方法
1.sleep使用sleep()方法使线程休眠。
2.yield在用于cpu控制权时可以使用yield方法可以让出cpu控制权。
3.interrupt中断线程。
4.isAlive判断线程是否处于活动状态。
5.isDaemon测试线程是否为守护线程。
6.getId返回线程标示符。
7.getName获取线程名
8.join等待该线程终止或使用join（long millis，int nanos）。

示例:

/*
简单的买票小程序
*/
class Ticket implements Runnable//定义一个类实现Runnable接口需要覆盖run方法
{
 private int tick=10000;//票数
 Object obj=new Object();//synchornized需要放一个对象.所以建立一个obj
 public void run()//覆盖的run方法
 {
  while(true)//循环
  {
   synchronized(obj)//同步代码块
   {
    if(tick>0)//判断票数小于零就不卖了
    {
     System.out.println(Thread.currentThread().getName()+"...."+tick--);//打印线程名称和票数
    }
   }
  }
 }
}
class TicketDemo
{
 public static void main(String[] args)
 {
  Ticket ti=new Ticket();

  Thread t1=new Thread(ti);//将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
  Thread t2=new Thread(ti);//一共开启四个线程
  Thread t3=new Thread(ti);
  Thread t4=new Thread(ti);

  t1.start();//开启两个线程
  t2.start();
  t3.start();
  t4.start();
 }
}

死锁示例:
class Test implements Runnable
{
 private boolean flag;
 Test(boolean flag)
 {
  this.flag = flag;
 }

 public void run()
 {
  if(flag)
  {
   while(true)
   {
    synchronized(MyLock.locka)//a锁
    {
     System.out.println(Thread.currentThread().getName()+"...if locka ");
     synchronized(MyLock.lockb)//b锁
     {
      System.out.println(Thread.currentThread().getName()+"..if lockb");     
     }
    }
   }
  }
  else
  {
   while(true)
   {
    synchronized(MyLock.lockb)//b锁
    {
     System.out.println(Thread.currentThread().getName()+"..else lockb");
     synchronized(MyLock.locka)//a锁
     {
      System.out.println(Thread.currentThread().getName()+".....else locka");
     }
    }
   }
  }
 }
}
class MyLock
{
 static Object locka = new Object();
 static Object lockb = new Object();
}

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

 

关于多线程单利设计模式的懒汉式
 懒汉式的特点在于延时加载
 但是在多线程访问的时候会出现安全问题
 解决问题:加同步(同步函数,和同步代码块都行)来解决但是有些低效.
 用双重判断的方法解决效率的问题
示例:

class Single
{
 private Single(){};
 private Single s=null;
 public static Singtle getInstance()
 {
  if(s==null)//使用双重判断的形式.
  {
   synchronized(Single.class)//锁是该类所属的字节码文件对象
   {
    if(s==null)
     s=new Single();
   }
  }
  return s;
 }
}

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