黑马程序员--java基础--多线程

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

目录:1、创建线程继承Thread类，2、创建线程run和start特点3、线程运行状态

4 、线程的第二种穿件方式实现Runnable接口5、多线程的安全问题6、多线程同步代码块7、多线程单列设计模式（懒汉式）8、多线程-死锁 9、线程间通信 10多线程lock 11、守护线程12、 多线程：13、Join方法

 

1创建线程 继承Thread类

建线程的第一种方式：继承Thread类.
步骤如下：
1 继承Thread类
2 覆写Thread类中的run方法
3 调用线程的start方法，这个方法有两个作用：

      1.启动线程2.调用run方法

class Demo extends Thread
{
 public void run()
 {
  for(int x= 0;x<60;x++)
  System.out.println("Demo run"+x);
 }
}
class ThreadDemo1
{
 public static void main(String[] args)
 {
 Demo d = new Demo();//定义了一个对象,其实就是创建好了一个线程
 d.start();//开启线程并执行该线程的run方法。
 d.run();
 for(int x= 0;x<60;x++)
  System.out.println("hello world"+x);
 }
}

2创建线程run和start特点
 d.start():开启线程并执行该线程的run方法。
 d.run():  仅仅是对象调用方法。而线程创建了，并没有运行。

为什么要覆盖run方法？
目的：将自定义代码存储在run方法中，让线程运行。

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

 

3线程运行状态
1被创建

2 运行

3 冻结状态（放弃了执行资格）

3 临时状态（阻塞状态，可以说是具备运行资格，但是没有执行权）

5 消亡
线程从被创建到运行，是通过start()方法！

线程运行到冻结，是通过sleep(time毫秒)方法结结束，是因为时间到了！冻结中还有休眠wait休眠状态对应的是被唤醒(notify)

4 线程的第二种穿件方式实现Runnable接口

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

5 调用Thread类的start方法开启线程并调用Runnable接口子类的run方法

创建多线程继承方式和实现方式的区别
实现方式：好处在于避免了但集成的局限性。
                 在定义线程时，建议使用实现方式implements
继承Thread:线程代码存放Thread子类run方法中
实现Runnable:线程代码存在接口的子类run方法

class Ticket implements Runnable
{
 private int tick= 100;
 public void run()
 {
  while(true)
  {
   if(tick>0)
   {
    System.out.println(Thread.currentThread().getName()+tick--);
   }
  }
 }
}
class TicketDemo {
 public static void main(String[] args)
 {
  Ticket t= new Ticket();
  Thread t1 = new Thread(t); 
  t1.start();
  Thread t2 = new Thread(t); 
  t2.start();
  Thread t3 = new Thread(t); 
  t3.start();
  Thread t4 = new Thread(t); 
  t4.start();
 }
}

5多线程的安全问题

 

问题的原因：
   当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完
   另一个线程就参与进来执行，导致共享数据的错误。
解决办法：
   对多条线程操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行

   Java对于多线程的安全问题提供了专业的解决方式：同步代码块

class Ticket2 implements Runnable
{
 private int tick = 100;
 Object obj = new Object();
 public void run()
 {
  while(true)
  {
   synchronized(obj)//加上的正确代码..
   {
    if(tick>0)
    {
    //让程序稍等10毫秒
     try{Thread.sleep(10);}catch(Exception e){}
     System.out.println(Thread.currentThread().getName()+tick--);
    }
   }
  }
 }
}
class TicketDemo2 {
 public static void main(String[] args)
 {
  Ticket2 tick1 = new Ticket2();
  Thread t1 = new Thread(tick1); 
  t1.start();
  Thread t2 = new Thread(tick1); 
  t2.start();
  Thread t3 = new Thread(tick1); 
  t3.start();
  Thread t4 = new Thread(tick1); 
  t4.start();
 }
}

6 多线程同步代码块

synchronized(对象)
{
 需要被同步的代码
}
假如把对象看成锁,持有锁的线程才可以在同步中执行。
没有持有锁的线程，即使获取cpu的执行权，也进不去，因为没有获取锁

多线程同步的前提：
1 必须要有两个或者两个以上的线程。
2 必须是多个线程使用同一个锁

必须保证同步中只能有一个线程在运行

好处：解决了多线程的安全问题。
弊端：多个线程都需要判断锁，较为消耗资源

7多线程单列设计模式（懒汉式）

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 SingleDemo {

}

8多线程-死锁

 

同步中还有同步导致程序停止

class Test implements Runnable
{
 private boolean flag;
 Test(boolean flag)
 {
  this.flag = flag;
 }
 public void run()
 {
  if(flag)
  {
   while(true)
   {
   synchronized(Lock.locka)
   {
    System.out.println("if locka");
    synchronized(Lock.lockb)
    {
     System.out.println("if lockb");
    }
   }
   }
  }
  else
  {
   while(true)
   {
   synchronized(Lock.lockb)
   {
    System.out.println("if lockb");
    synchronized(Lock.locka)
    {
     System.out.println("if locka");
    }
   }
   }
  }
 }
}
class Lock //创建一锁
{
 static Lock locka = new Lock();
 static Lock lockb = new Lock();
}
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();
 }
}

9线程间通信

其实就是多个线程在操作同一个资源,操作的动作不同
 
 思考：
 1 wait(),notify(),notify()All用来操作线程，为什么定义在了Object类中
   1 这些方法存在于同步汇中
   2 使用这些方法时，必须要标识所属的同步锁
   3 锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中
 2 wait()和sleep()有什么区别?
    wait()释放资源,释放锁
   sleep() 释放资源,不释放锁

线程间通信-等待唤醒机制
总结：wait();notify();notifyAll();都要使用在同步中，因为要对持有监视器(锁)的线程操作
所以要使用在同步中，因为只有同步才有锁的概念.
为什么这些操作线程的操作要定义在Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，
只有同一个锁上的被等待线程可以被同一个锁上的notify唤醒；
不可以对不同锁中的线程进行唤醒.

也就是说，等待和唤醒必须是同一把锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

class Res
{
 String name;
 String sex;
 boolean flag = false;
}
//输入
class Input implements Runnable
{
 private Res r;
 Input(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  boolean b = true;
  while(true)
  {
   synchronized(r)
   {
    if(r.flag)
    try{r.wait();}catch(Exception e){}
     if(b)
     {
      r.name = "mike";
      r.sex = "man";
      b = false;
     }
     else
     {
      r.name = "丽丽";
      r.sex = "女 女 女 女";
      b = true;
     }
    r.flag = true;
    r.notify();
   }
  }
 }
}
//输出
class Output implements Runnable
{
 private Res r;
 Output(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  //建立循环，为了多次执行输出，找错误
  while(true)
  {
   synchronized(r)
   {
    if(!r.flag)
   try{r.wait();}catch(Exception e){}
   System.out.println(r.name+"............"+r.sex);
    r.flag = false;
   r.notify();
   }
  }
 }
}
class InputOutputDemo {
 public static void main(String[] args)
 {
  Res r = new Res();
  Input in = new Input(r);
  Output ou = new Output(r);
  Thread t1 = new Thread(in);
  Thread t2 = new Thread(ou);
  t1.start();
  t2.start();
  
 }
}

10多线程lock

提供了多线程的升级解决方案，将synchronized替换成了显示的Lock操作
将Object中的 wait，notify,notifyAll替换成了Condition对象await,signal,signalAll
该对象可以通过Lock锁进行获取

在该示例中，实现了本方只唤醒对方的操作

class Resource
{
 private String name;
 private int count = 1;
 private boolean flag = false;
 private Lock lock = new ReentrantLock();
 private Condition condition_pro = lock.newCondition();
 private Condition condition_con = lock.newCondition();
 //生产功能
 public void set(String name)throws InterruptedException 
 {
  lock.lock();
  try{
   while(flag)
    condition_pro.await();
   this.name = name+"--"+count++;
  
   System.out.println(Thread.currentThread().getName()+"..生产者.."+this.name);
   flag = true;
   condition_con.signal();
  }
  finally
  {
   lock.unlock();
  }
 }
 public void out()throws InterruptedException 
 {
  lock.lock();
  try{
  while(!flag)
   condition_con.await();
  System.out.println(Thread.currentThread().getName()+"...消费者"+this.name);
  flag = false;
  condition_pro.signal();//释放对方的锁
  }
  finally
  {
   lock.unlock();//释放锁的动作一定要执行
  }
 }
}
//生产者
class Producer implements Runnable
{
 private Resource res;
 Producer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  while(true)
  {
   try {
    res.set("商品");
   } 
   catch (Exception e) 
   {
    
   }
  }
 }
}
//消费者
class Consumer implements Runnable
{
 private Resource res;
 Consumer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  while(true)
  {
   try
   {
  res.out();
   }
   catch(InterruptedException e)
   {
   }
  }
 }
}
//主函数
class ProducerConsumerDemo2 {
 public static void main(String[] args)
 {
  Resource re = new Resource();
  Producer pro = new Producer(re);
  Consumer cou = new Consumer(re);
  Thread t1 = new Thread(pro);
  Thread t2 = new Thread(pro);
  Thread t3 = new Thread(cou);
  Thread t4 = new Thread(cou);
  t1.start();
  t2.start();
  t3.start();
  t4.start();
  
 }
}

11守护线程

将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。
通俗点说：就是前台进程全部结束完之后，守护线程自动就退出了。

//需求：停止线程
class StopThread implements Runnable
{
 private boolean flag = true;
 //public synchronized void run()
 public synchronized void run()
 {
  while(flag)
  {
   try
   {
    wait();
   }
   catch(InterruptedException e )
   {
    System.out.println(Thread.currentThread().getName()+"呀呀呀呀呀0.0");
    //如果都已经捕获到异常，就更改flag
    //this.flag =false;
   }
   System.out.println(Thread.currentThread().getName()+"....run");
  }
  this.flag = false;
 }
}
class SetDaemonDemo {
 public static void main(String[] args)
 {
  StopThread st = new StopThread();
  Thread t1 = new Thread(st);
  Thread t2 = new Thread(st);
  //setDaemon必须要在现在标记出来。
  t1.setDaemon(true);
  t2.setDaemon(true);
  t1.start();
  t2.start();
  
  int num = 0 ;
  while(true)
  {
   if(num++ ==60)
   {
    //结束进程
    //t1.interrupt();
    //t2.interrupt();
    break;
   }
   System.out.println(Thread.currentThread().getName()+"...."+num);
  }
  System.out.println("over");
 }
}

12 多线程：Join方法

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

class Demo implements Runnable
{
 public void run()
 {
  for(int x = 0; x<70; x++)
  {
   System.out.println(Thread.currentThread().getName()+"...."+x);
  }
 }
}
class JoinDemo {
  public static void main(String[] args)throws Exception
  {
   Demo d = new Demo();
   Thread t1 = new Thread(d);
   Thread t2 = new Thread(d);
   t1.start();
   t1.join();
   t2.start();
   for(int x = 0;x<60;x++)
   {
    System.out.println("main...."+x);
   }
   System.out.println("over");
  }
}

 

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