黑马程序员---JAVA之多线程

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

1、实现多线程的两种方法，及其区别：

两种方法：实现方式（implement runnable)和继承方式(extends Thead)。

区别：因为java的单继承特性，如果用继承Thread类的方式来实现多线程的话，此线程类就不能继承其他的类了。所以在程序中往往要求用实现Runnable的方式来开发会更好。
这两种方式最大的区别是在资源共享的问题，继承Thread类的多个线程之间不能实现资源的共享，而实现Runnable接口后可以实现多个线程之间的资源共享。

2、线程的五种状态：

①NEW（新建）：这种情况指的是，通过New关键字创建了Thread类（或其子类）的对象

②RUNNABLE（就绪）：这种情况指的是Thread类的对象调用了start()方法，这时的线程就等待时间片轮转到自己这，以便获得CPU；第二种情况是线程在处于RUNNABLE状态时并没有运行完自己的run方法，时间片用完之后回到RUNNABLE状态；还有种情况就是处于BLOCKED状态的线程结束了当前的BLOCKED状态之后重新回到RUNNABLE状态。

③RUNNING（运行）：这时的线程指的是获得CPU的RUNNABLE线程，RUNNING状态是所有线程都希望获得的状态。

④BLOCKED（阻塞）：这种状态指的是处于RUNNING状态的线程，出于某种原因，比如调用了sleep方法、等待用户输入等而让出当前的CPU给其他的线程。

⑤DEAD（死亡）：处于RUNNING状态的线程，在执行完run方法之后，就变成了DEAD状态了。

3、看代码需不需要同步的原则：

①明确那些代码是多线程代码。

②明确共享数据。

③明确多线程运行中哪些语句是操作共享数据的。

4、线程及其同步的一些小知识点：

线程必须实现run方法，run方法存储要执行的代码。

Thread类的start方法开启线程并调用Runnable接口子类中的run方法。而如果直接调用run方法的话，则不会开启新的线程。

synchronized处理线程同步问题。需要同步就看哪些语句在操作共享数据。格式为synchronized(obj){}，只有同步才具有锁；只能对同一锁中的线程进行唤醒，即等待和唤醒必须是同一个锁。

同步函数使用的锁是this ；同步函数被静态修饰后，使用的锁不再是this，因为静态方法中不可以并列this，使用的是该方法所在类的字节码文件对象，即：类名.class。

同步的弊端：有时候会产生死锁。  例如当同步中嵌套同步，而锁却不同时。

wait() 和sleep()的区别 ：wait释放资源，释放锁；sleep释放资源，不释放锁。

JDK1.5之后，用Lock代替Synchronized操作，将Object中的wait,notify,notifyAll替换成了Condition的await,signal,signalAll；即显示的锁机制，以显示的锁机制的唤醒机制代替以前的机制。一个锁可以对应多个condition。释放锁的动作一定要执行。

示例代码如下：

class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition(); 
   final Condition notEmpty = lock.newCondition(); 

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[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];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }

停止线程只能让run方法结束，而只要控制住循环，就可以让run方法结束，也就结束线程。Thread类提供的Interrupt方法，可以强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

守护线程在没有用户线程可服务时自动离开 ,在Java中比较特殊的线程是被称为守护（Daemon）线程的低级别线程。 这个线程具有最低的优先级，用于为系统中的其它对象和线程提供服务。 将一个用户线程设置为守护线程的方式是在线程对象创建之前调用线程对象的setDaemon方法。  守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。 也就是说守护线程不依赖于终端，但是依赖于系统，与系统“同生共死”。 当JVM中所有的线程都是守护线程的时候，JVM就可以退出了； 如果还有一个或以上的非守护线程则JVM不会退出。
线程中的join方法是索要cpu资源，当A线程执行到了B线程的join()方法时，A就会等待，等Ｂ线程都执行完了，Ａ才会执行。join可以用来临时加入线程执行。

所有线程（包括主线程）的默认优先级是5。

5、单例模式及其同步：

①懒汉式代码

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 Single
{
    private static final Single  s = new Single(){
        private Single(){}
        public static Single getInstance()
        {
            return s;
        }
        
    }
}

6、一个小的例子：

<pre name="code" class="java">//java多线程模拟生产者消费者问题
//ProducerConsumer是主类，Producer生产者，Consumer消费者，Product产品
//Storage仓库
public class ProducerConsumer {

	public static void main(String[] args) {
		Storage s = new Storage();
		Producer p = new Producer(s);
		Consumer c = new Consumer(s);
		Thread tp = new Thread(p);
		Thread tc = new Thread(c);
		tp.start();
		tc.start();

	}
}

class Consumer implements Runnable {//消费者	
	Storage s = null;
	public Consumer(Storage s){
		this.s = s;
	}
	public void run() {
		for(int i=0; i<20; i++){
			Product p = s.pop();//取出产品
			try {
				Thread.sleep((int)(Math.random()*1500));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		
	}

}

class Producer implements Runnable {//生产者
	Storage s = null;
	
	public Producer(Storage s){
		this.s = s;
	}

	public void run() {
		for(int i=0; i<20; i++){
			Product p = new Product(i);
			s.push(p);	//放入产品
//			System.out.println("生产者放入：" + p);
			try {
				Thread.sleep((int)(Math.random()*1500));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

class Product {
	int id;
	
	public Product(int id){
		this.id = id;
	}
	
	public String toString(){//重写toString方法
		return "产品："+this.id;
	}
}


class Storage {
	int index = 0;
	Product[] products = new Product[5];
	
	public synchronized void push(Product p){//放入
		while(index==this.products.length){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.products[index] = p;
		System.out.println("生产者放入"+index+"位置：" + p);
		index++;
		this.notifyAll();
	}
	
	public synchronized Product pop(){//取出
		while(this.index==0){
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		index--;
		this.notifyAll();
		System.out.println("消费者从"+ index+ "位置取出：" + this.products[index]);
		return this.products[index];
	}
}