黑马程序员_Java基础(4)--多线程

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

(day11多线程)**********************************************************************
@@多线程
进程：是一个正在执行中的程序，每一个进程执行都有执行顺序，该顺序是一个执行路径，或者叫控制单元。
线程：就是进程中独立的控制单元，线程在控制着进程的执行。
一个进程中至少有一个线程，
(线程是程序的控制单位或着叫执行路径。)

java jvm 启动时候会有一个进行java.exe
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在main方法中，该线程称之为主线程。
jvm启动至少有两个线程：一个是主线程，一个是负责垃圾回收机制的线程。

自定义一个线程。
1，继承Thread类，重写run方法。
2，实现Runnable接口，重写run方法。

@@第一种：继承Thread类，重写run方法
1，定义类继承Thread类;class Demo extends Thread
2，重写Thread类中的run方法：将自定义的代码存储在run方法中，让线程运行。
3，调用start() 方法，使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
Demo d = new Demo();
d.start();
多线程的一个特性：随机性，谁抢到cpu，谁就先执行，至于执行多长时间cpu说的算。
为什么覆盖run方法？
Thread类用于描述线程。该类就定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储程序要运行的代码。
线程运行状态：
<被创建>--start--<运行>--sleep(time)--<冻结>--sleep的time到了--<运行>-
<被创建>--start--<运行>--wait(timeout)--<冻结>--notify--<运行>-
<被创建>--start--<运行>--stop()/或run()结束--<消亡>
<被创建>--start--<临时/阻塞>--<运行>--stop()/或run()结束--<消亡>
被创建：Demo d = new Demo();d.start();
运行：既有执行资格，由有执行权。
临时/阻塞：具备执行资格，但没有执行权，执行权在别的线程手上。
冻结：放弃了执行资格。
消亡：run()执行完，线程结束。
static void sleep(long millis) ：等待millis毫秒。
static Thread currentThread() 返回对当前正在执行的线程对象的引用。
String getName() 返回该线程的名称
设置线程名称：构造函数或setName()方法
线程名称：
有自己的默认名称Thread-0...;
也可以初始化时定义名称
class Demo extends Thread
{
 Demo(String name)
 {
 super();
 }
 public void run
 {
  for(int x=0;x<100;x++)
  {
  System.out.println((Thread.currentThread()==this)+":"+this.name+x);
  }
 }
}

@@第二种：实现Runnable接口，重写run()方法。将实现Runnable接口的类对象传递给Thread类的构造函数。
大多数情况下，如果只想重写 run() 方法，而不重写其他 Thread 方法，那么应使用 Runnable 接口。
这很重要，因为除非程序员打算修改或增强类的基本行为，否则不应为该类创建子类。
1，定义类实现接口Runnable，并重写run方法：class Demo implements Runnable
2，建立Thread对象，并将Runnable的实现类传递给Thread类的构造函数
3，调用Thread类的start方法开启线程。
Demo d = new Demo();
Thread t = new Thread(d);//将d作为实际参数传递给Thread类的构造函数
t.start();//开启线程，并执行d中的run方法。
**实现方式和继承方式的区别？*******
实现方式的好处：避免了单继承的局限性。
继承Thread：线程代码存放在Thread子类的run方法中。
实现Runnable：线程代码存在实现接口的类的run方法中。
在定义线程时，建议最好使用实现接口Runnable的方式。

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

java对于多线程的安全问题的解决方式-->同步(同步代码块和同步函数)******
@@同步代码块
class Demo implements Runnable{
private int tick = 1000;//共享数据
Object obj = new Object();//为同步代码块创建一个锁/对象
public void run(){
不需要同步的代码；
synchronized(对象/锁 obj)//同步代码块
{
 需要被同步的代码；
 try{Thread.sleep(100);}catch{InterruptedException ie}
 //不能在函数位置上throws InterruptedException，
 //因为实现的接口没有抛出任何异常，所以只能在内部try处理。
}
}
}
同步代码块的原理：
对象存在的时候有个标志位，默认为0；
当Thread-0线程进入同步代码块时，先判断该对象的标志位，
    如果为0，表示同步代码快内部没有线程，可以进入，所以Thread-0进入该代码块，同时对象的标志位改为1；
当Thread-1、2、3...等线程想要进入同步代码块时，先判断该对象的标志位，
    如果为1，表示同步代码快内部有1个线程，不可以进入，所以Thread-1没有进入该线程，保证了同步代码快内的共享数据的安全性；
当Thread-0线程执行完同步代码块中的语句时，离开代码块，然后同时该对象的标志位变为0，表示同步代码快内没有线程，其他线程可以进入；

同步的前提；***************
1，必须要有两个或者以上的线程。
2，必须是多个线程使用同一个锁()。//不能同步代码快用obj锁，同步函数用this锁。！！！！****
必须保证同步中只有一个线程在运行。
同步的好处：解决了多线程的安全问题。
同步的弊端：多个线程需要判断锁，较为消耗资源。

在程序中查找安全问题：
1，明确哪些代码是多线程运行代码；
2，明确哪些是共享数据；
3，明确多线程代码中哪些语句是操作共享数据的。

同步的表现形式：同步代码块和同步函数
@@同步函数:
public void run()
{
 不需要同步的代码；
 show();
 //如果有同步代码块，切记要和show()函数用同一个锁this,否则不安全！！！！！
 //synchronized(this){}
}
public synchronized void show()//默认的锁是this
{
 (只是)需要被同步的代码；//只把操作共享数据的语句放这！！
 try{Thread.sleep(100);}catch{InterruptedException ie}
 //不能在函数位置上throws InterruptedException，
 //因为实现的接口没有抛出任何异常，所以只能在内部try处理。
}
@@锁
同步代码块的锁： 同一个对象/锁(可以是this、Demo.class可以是另外的对象)
同步函数的锁：this  (调用此同步函数的实例对象)
 函数需要被对象调用，函数都有一个所属对象引用，就是this。
静态同步函数的锁：类名.class (静态同步函数所在类 的字节码文件对象)

同步的前提一定要使用同一个锁！！！！
@@死锁： 同步中嵌套同步。两个同步的锁不一样！
写一个死锁程序：
(day12)*******************************************************************
@@wait,notify,notifyAll，用来操作线程为什么定义在了Object类中？
1，这些方法存在于同步中，都用在同步中。因为这些方法要对持有监视器(锁)的线程操作。
2，使用这些方法必须要标识其所属的同步的锁。锁.wait() 锁.notify() 锁.notifyAll().
3，锁可以是任意对象，所以任意对象调用的方法一定定义在Object类中。
等待和唤醒必须是同一把锁。
(wait有异常抛出InterruptedException,notify没有异常抛出)
wait和sleep的区别？//都有InterruptedException异常。
wait：释放资源，释放锁。
sleep：释放资源，不释放锁。
线程间通信：其实就是多个线程操作同一个资源，但是操作的动作不一样。
等待唤醒机制：
例1：单个消费者交替运行，和单个生产者，同步；
class Res //专门用来存放和处理 多线程中的共享数据！
{
  private String name;
  private String sex;
  private boolean flag = false;
  public synchronized void set(String name,String sex)
 { 
   if(flag)//set重复执行的时候，flag为真，说明容器有了一个赋值，进入wait，等待输出函数的notify
    //out执行完后转过来，flag为假，说明容器中没有赋值，然后跳过wait，进入赋值程序。
   try{this.wait();}catch (Exception e){}
   this.name = name;
   this.sex = sex;
   flag = true;//赋值完成后，flag为真，容器中有值，提醒out函数可以进行输出。
   this.notify();//唤醒out的notify
 }
 public synchronized void out()
 {
  if(!flag)//set执行完后转过来，flag真--容器有值--输出；
    //out重复执行的时候，flag为假--容器无值--进入wait，等待set的notify唤醒。
   try{this.wait();}catch (Exception e){}
  System.out.println(name+"..."+sex);
  flag = false;//flag为假，说明容器中没有赋值
  this.notify();//唤醒set
 }
}
class Input implements Runnable//实现两种赋值方式的交替运行
{
 private Res r ;
 Input(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  int x = 0;//为了让线程t1交替进行赋值。
  while(true)//让程序多次运行，更容易看出效果。
  { 
    if(x == 0)//为了让线程t1交替进行赋值。
    {
     r.set("wzq","nan");
    }
    else
    {
     r.set("蛋蛋","女");
    }
    x = (x+1)%2;//为了让线程t1交替进行赋值。   
  }  
 }
}
class Output implements Runnable//实现容器中的值，交替输出。
{
 private Res r ;
 Output(Res r)
 {
  this.r = r;
 }
 public void run()
 {
  while(true)//让程序多次运行，更容易看出效果。
  {
   r.out();
  }  
 }
}
class InputOutputDemo
{
 public static void main(String[] args) throws Exception
 {
  Res r = new Res();
  Thread t1 = new Thread(new Input(r));
  Thread t2 = new Thread(new Output(r));
  t1.start();  
  t2.start();
 }
}
例2：多个生产者和消费者同步进行；
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，
因为需要唤醒对方线程。(不是很优化)
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
*/
class Resource
{
 private String thing;
 private int count = 1;
 private boolean flag = false;
 public synchronized void set(String thing)
 {
  while(flag)
   try{this.wait();}catch(InterruptedException e){}
  this.thing = thing;
  this.count = count;
  System.out.println(Thread.currentThread().getName()+"生产"+thing+count);
  flag = true;
  this.notifyAll();
 }
 public synchronized void out()
 {
  while(!flag)
   try{this.wait();}catch(InterruptedException e){}
  System.out.println(Thread.currentThread().getName()+"消费@@@@"+thing+(count++));
  flag = false;
  this.notifyAll();
 }
}

class Producer implements Runnable
{
 private Resource res;
 Producer(Resource res)
 {
  this.res = res;
 }
 public void run()
 { 
  while(true)//让线程多次运行，容易看出结果。
   res.set("苹果");
 }
}
class Consumer implements Runnable
{
 private Resource res;
 Consumer(Resource res)
 {
  this.res = res;
 }
 public void run()
 {
  while(true)//让线程多次运行，容易看出结果。
   res.out();
 }
}
class demo
{
 public static void main(String[] s)
 {
  Resource res = new Resource();
  Producer pro = new Producer(res);
  Consumer con = new Consumer(res);
  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();
 }
}
例3：(JDK1.5后)；有一个Object数组，长度100，可以实现多个线程同时进行存储和取出元素。而且数组可以多次使用。
/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。

@@Lock:替代了Synchronized(语句和函数)：   Lock lock = new ReentrantLock();
 lock //获取锁   lock.lock();
 unlock//释放锁   lock.unlock;
 newCondition()//返回绑定此lock实例的心Condition实例

@@Condition：替代了Object中的wait notify notifyAll；   Condition con = lock.newCondition();
 await();//等待     con.await();//要抛异常InterruptedException
 signal();//唤醒相应的锁    con.signal();
 signalAll();//唤醒相应的所有的锁  con.signalAll();
*/
import java.util.concurrent.locks.*;
class BoundedBuffer
{
 final Lock lock = new ReentrantLock();
 final Condition notFull = lock.newCondition();
 final Condition notEmpty = lock.newCondition();
 
 final Object[] items = new Object[100];
 int count,putptr,takeptr;

 public void put(Object x)throws InterruptedException
 {
  lock.lock();
  try
  {
   while(count==items.length)
    notFull.await();
   items[putptr] = x;
   System.out.println(Thread.currentThread().getName()+"在向数组中添加第"+putptr+"号角标的元素："+x);
   if(++putptr == items.length)
    putptr = 0;
   ++count;
   notEmpty.signal();
  }
  finally
  {
   lock.unlock();
  }
 }
 public Object take()throws InterruptedException
 {
  lock.lock();
  try
  {
   while(count==0)
    notEmpty.await();
   Object x = items[takeptr];
   System.out.println(Thread.currentThread().getName()+"在从数组中取出第"+takeptr+"号角标的元素："+x);
   if(++takeptr == items.length)
    takeptr = 0;
   --count;
   notFull.signal();
   return x;
  }
  finally
  {
   lock.unlock();
  }
 }
}
class Put implements Runnable
{
 BoundedBuffer bb;
 int x = 20;
 Put(BoundedBuffer bb)
 {
  this.bb = bb;
 }
 public void run()//不能抛，只能在内部进行try
 {
  while(x-->0)
  {
   try
   {
    bb.put(x);
   }
   catch (InterruptedException e)
   {
   }   
  }
 }
}
class Take implements Runnable
{
 BoundedBuffer bb;
 int x = 20;
 Take(BoundedBuffer bb)
 {
  this.bb = bb;
 }
 public void run()//不能抛，只能在内部进行try
 {
  while(x-->0)
  {
   try
   {
    System.out.println(bb.take());
   }
   catch (InterruptedException e)
   {
   }   
  }
 }
}
class demo
{
 public static void main(String[] s)
 {
  BoundedBuffer bb = new BoundedBuffer();
  Put p = new Put(bb);
  Take t = new Take(bb);
  new Thread(p).start();
  new Thread(p).start();
  new Thread(p).start();
  new Thread(p).start();

  new Thread(t).start();
  new Thread(t).start();
  new Thread(t).start();
 }
}
@@停止线程：原理：让线程中的run方法可以结束。
1，定义循环结束标记。
特殊情况:
当线程处于了冻结状态。就不会读取到标记，那么线程就不会结束。
2，使用interrupt(中断)方法,(创造一次InterruptedException,然后在catch中进行合理的处理，使线程结束)。
void interrupt()
          中断线程。中断 线程的冻结状态 ，然后如果不catch的话线程可能会继续冻结。
如果线程进入了冻结状态，而且也没有别的线程调用notify对其进行唤醒。
那么。可以让线程中断一次，然后再在catch中进行异常处理，将线程结束。
boolean flag = true;
public synchronized void run()
{
 while(flag)
 {
  try
  {
   wait();//进入冻结状态，而且没有别的线程将其唤醒。
  }
  catch (InterruptedException e)
  {
   flag = false;
  }
 }
}
public static main(String[] s)
{
 Thread t1 = new Thread(demo);
 t1.start();//进入冻结状态，而且没有别的线程将其唤醒。
 t1.interrupt();//创造一次InterruptedException异常，然后线程的run方法中对冻结状态进行处理，让线程正常结束。
}
sleep/wait/join都可以进入冻结状态，都可以用interrupt进行中断。
@@守护线程:(后台线程，用户线程)
setDaemon (boolean on)
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。
t1.setDaemon(true);
t2.setDaemon(true);
t1.start();
t2.start();
当所有的前台线程结束后(main也是前台线程)，后台线程自动结束！！！后台依赖前台线程！
一般线程都是前台线程，t.setDaemon(true)才会变为后台程序。

@@t.join：
'谁'碰到了t.join,t就要抢夺'谁'的执行权，然后'谁'被冻结了。
 当t运行(期间如果有别的线程也运行，则会和t一起再抢执行权)，当t运行完，'谁'才会再继续执行.
当A线程执行到了B线程的.join()方法时，A就会等待。B线程开始执行(期间有别的线程会和B一起再抢执行权)，
 但是只有当B完全结束后，A才会继续执行。
B.join相当于A和B交换了争夺执行权的资格。等B执行完后，A才有争夺执行权的资格。
join可以用来临时加入线程执行。
@@toString()
返回该线程的字符串表示形式，包括线程名称、优先级和线程组。
哪个线程(如B)开启了该线程A，A就属于B。ThreadGroup(String name)构造一个新线程组。

优先级(1---10,默认为5)：优先级越高，执行的机会越多。
setProiority(int x);
 Thread.MAX_PRIORITY最高；Thread.MIN_PRIORITY最低优先级；Thread.NORM_PRIORITY默认
getProiority();

@@Thread.yield()
static void yield()
          暂停当前正在执行的线程对象，并执行其他线程。
开发中多线程的使用情况：但一段代码需要同时被执行时，(与主函数一起执行，或与其他线程一起执行)

new Thread()//把下面的代码放进一个线程中，与其他线程同步执行。
{
 public void run()
 {
  for(int x=0; x<100; x++)
  {
   System.out.println(Thread.currentThread().getName()+"....."+x);
  }
 }
}.start();//开启一个线程

for(int x=0; x<100; x++)//主函数中的一个线程
{
 System.out.println(Thread.currentThread().getName()+"....."+x);
}

Runnable r  = new Runnable()//把下面的代码放进一个线程中，与其他线程同步执行。
{
 public void run()
 {
  for(int x=0; x<100; x++)
  {
   System.out.println(Thread.currentThread().getName()+"....."+x);
  }
 }
};
new Thread(r).start();//开启一个线程

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