黑马程序员---多线程【java】

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

1、多线程

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

线程：是进程中的一个独立的控制单元，线程控制着进程的执行。一个进程至少有一个线程。

创建线程的第一种方式：继承Thread类。

A、  定义类继承Thread类。

B、  复写Thread类中的run方法。

C、  调用线程的start方法。该方法两个作用：启动线程、调用run方法。

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

创建线程的第二种方法：

A、  定义类实现Runnable接口。

B、  覆盖Runnable接口中的run方法。

C、  通过Thread类建立线程对象。

D、  将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

E、  调用Thread类的start方法，开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式的区别：

实现方式避免了单继承的局限性。

安全问题

解决线程安全问题：同步代码块

synchronized（对象）

{

         需要被同步的代码；

}

对象如同锁，持有锁的线程可以在同步中执行。

同步的前提：

A、  必须要有两个或者两个以上的线程。

B、  必须是多个线程使用同一个锁。

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

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

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

JDK1.5 中提供了多线程升级解决方案。

将同步Synchronized替换成Lock操作。
将Object中的wait,notify,notifyAll,替换了Condition对象。
该对象可以通过Lock锁进行获取。

示例：

import java.util.concurrent.locks.*;
class ProducerConsumerDemo2
{
 public static void main(String[] args)
 {
  Resource r=new Resource();
  Producer pro=new Producer(r);
  Consumer con=new Consumer(r);
  Thread t1=new Thread(pro);
  Thread t2=new Thread(pro);
  Thread t3=new Thread(con);
  Thread t4=new Thread(con);
  t1.start();
  t2.start();
  t3.start();
  t4.start();
 }
}

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();//释放锁的动作一定要执行。
  }
  this.notifyAll();
 }
 public void out()throws InterruptedException
 {
  lock.lock();
  try
  {
   while(!flag)
    condition_con.await();
   this.name=name+"--"+count++;
   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 (InterruptedException 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)
   {
   }
  }
 } 
}