[java理论篇]---java的线程

1、线程的创建方法：继承Thread类，实现Runable接口；

2、继承Thread类创建的线程，复写run方法即可，然后使用start方法启动线程；

3、实现Runable接口的线程，其实与线程没有直接关系，就算有了run方法，要明确与线程有直接关系的是Thread类，创建线程还是要依赖Thread类的，所以一个实现Runable的类并且有run方法，要是使用Thread的构造方法才能真正创建线程，然后必须使用Thread的start方法，才能启动一个线程；

4、线程的状态：新建、就绪、运行、死亡、阻塞；

5、线程的安全：设想一个共享资源也就是临界资源，多个线程同时访问的时候，由于CPU的执行权的不确定性，就会造成共享资源的不安全，解决办法很简单，就是将共享代码块加上同步，或者将一个共享函数加上同步，变为同步函数；这时候还要强调一点：加同步的时候需要一个锁对象，可以是任意对象，当然执行效率降低了；当一个临界资源被多线程访问的时候，并且线程是同步的，但是使用的锁对象不是同一个，就容易进入死锁的状态；

6、一个单例模式(安全高效)：懒汉式

   class Single{

    private Static Single s=null;

    private Single(){}

    Public  Static Single getInstance(){

           if(s==null){

              synchronized(Single.class){

                    if(s==null)

                    return s= new Single();

                 }

              }

    }

   }

7、线程的通信：在设想一种情况，一个共享资源，被多个线程访问，并且这个资源被各个线程的run方法所操作行为不一样，典型的便是生产者和消费者，一个生产一个消费，此时，便涉及到了线程的通信问题，当然解决办法依然是加同步，除此以外，你要考虑：当一个线程执行完后，如何通知其他相应的线程去执行，下面是一个简单完整的生产者和消费者的实例，体会一下线程间的通信不同之处：

class ProducerConsumerDemo
{
    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();
    }
}
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。
为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
*/
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
            //  t1    t2
    public synchronized void set(String name)
    {
        while(flag)
            try{this.wait();}catch(Exception e){}//t1(放弃资格)  t2(获取资格)
        this.name = name+"--"+count++;
        System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
        flag = true;
        this.notifyAll();
    }
    //  t3   t4
    public synchronized void out()
    {
        while(!flag)
            try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
        System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
        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();
        }
    }
}

下面给出最新版本的实例：

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();
    }
}
/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify notifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方操作。
Lock:替代了Synchronized
    lock
    unlock
    newCondition()
Condition：替代了Object wait notify notifyAll
    await();
    signal();
    signalAll();
*/
class Resource
{
    private String name;
    private int count = 1;
    private boolean flag = false;
            //  t1    t2
    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();//t1,t2
            this.name = name+"--"+count++;
            System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
            flag = true;
            condition_con.signal();
        }
        finally
        {
            lock.unlock();//释放锁的动作一定要执行。
        }
    }
    //  t3   t4
    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 (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)
            {
            }
        }
    }
}

8、线程的其他要点：

     线程的优先级、线程的停止；守护线程