多线程

1. 进程：一个程序是一个进程，一个程序主函数执行就是一个进程，电脑上可以同时有多个进程同时运行，叫并发。2个CPU4个核一共就能并行4个程序，进程多，按时间片轮转获得资源。

2. 线程：一个进程可以包含多个线程，如启动一个QQ是一个进程，QQ同时可以聊天，可以弹广告消息，线程是进程的一个执行线索，线程数多的时候，线程数跟核数相等就并行，不等就时间片轮转。

3. 进程之间交互通信，不方便，线程之间很很方便（一个进程内的）。

4. 程序运行时，先启动线程，按照代码（线路）来执行。

5. 继承Thread类实现多线程：1. 自己实现的线程类要继承Thread类 2. 重写run（）方法，run方法里是该线程要执行的操作。

                                       开启线程方法：new线程类对象，用该对象调用start（）方法。start方法会调用ran方法。

　　　　　　　　　　　　　　如果直接调用run方法，如果run方法是死循环，就会一直执行run方法，这样就是自己实现的线程的线程一直在跑，

　　　　　　　　　　　　　　无法执行其他线程，就是资源都被这个线程占用，这个线程一直在执行，直到执行结束。

　　　　　　　　　　　　　　调用start方法会在线程启动前向系统申请资源，分配执行的时间片，申请到cpu后，再调用run（）方法执行。

6 .实现Runnable接口： 1.自己实现的线程类要实现Runnable类，Runnable接口中只定义了一个run（）方法，2.自己实现的类中实现run（）方法。

                                开启线程方法:new Thread(new RunTread()).start(); 其实是Thread类中有个构造方法 Thread(Runnable runnable)可以传

　　　　　　　　　　　 实现了Runnable接口的子类，启动线程还是调用了Thread类的start（）方法。

　　　　　　　　　　　 这种方式就是不用继承Thread类，自己实现的线程类可以继承别的类了。

7. start（）方法如何申请资源： 源码中可以看成 start方法调用源码中一个native的start0方法来实现资源配置。native方法为java与非java代码交互的关键字，

　　　　　　　　　　　　　　　如调用c代码，JVM将控制调用本地方法的所有细节，具体看另外native博客。

   源码：

 public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

    /**
     * If this thread was constructed using a separate
     * <code>Runnable</code> run object, then that
     * <code>Runnable</code> object's <code>run</code> method is called;
     * otherwise, this method does nothing and returns.
     * <p>
     * Subclasses of <code>Thread</code> should override this method.
     *
     * @see     #start()
     * @see     #stop()
     * @see     #Thread(ThreadGroup, Runnable, String)
     */
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

8. 进程分为前台进程和后台进程 后台进程在主函数（也是个进程）中执行的话，如果主函数进程结束，后台进程也结束，前台进程则不受影响。后台线程也叫守护线程。

public static void main(String[] args) {
        Thread t = new Ticket();
        t.setDaemon(true);//设置为后台进程
        t.start();

9. 线程的联合 join 

package weiguoyuan.chainunicom.cn;

class Ticket extends Thread {
    public void run() {
        while(true) {
            System.out.println(Thread.currentThread().getName()+ " );
        }        
    }
}


public class TestThread {

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Ticket();
        t.start();
        
        int i = 0;        
        while(true) {
            i++;
            System.out.println(Thread.currentThread().getName());
            if(i==10000) {
                t.join(6666); //6666为毫秒数 ，将t线程联合过来 只执行t直到6666毫秒过后 恢复
            }
        }
    }

}

10. 例子 经典卖票程序 3窗口卖1000

<1. 3个线程 分别有自己的tickets 这样就卖出了 3000张票

package weiguoyuan.chainunicom.cn;

class Ticket extends Thread {
    private int tickets = 1000;
    public void run() {
        while(tickets>0) {
            System.out.println(Thread.currentThread().getName()+ " "+tickets--);
        }        
    }
}

public class TestThread {

    public static void main(String[] args) {
        new Ticket().start();
        new Ticket().start();
        new Ticket().start();
    }
}

<2. 在tickets上加上static 资源共享 3个线程动作相同 瓜分现象

private static int tickets = 1000;

<3. 线程的同步问题，当多个线程同时进入run（）方法中，操作tickets--，如假如当前tickets为1，1，2线程两个线程，1线程先得到时间片判断tickets>0，然后还没执行到tickets--这句代码，2号线程抢到时间片进入run（）方法也判断tickets>0，然后执行tickets--，这时tickets已经为0了，结束线程，这时1线程得到时间片执行tickets--，tickets=-1，显然已经出错。

解决办法：用锁锁住run（）方法，锁住判断和操作资源，让这两步为一个原子，当一个线程进来判断时，不允许其他进程进入。

　　　　　第一种锁： synchronized 同步代码块，同步的 的意思，实现方法：Object类，即每个对象都有2种状态，低电平0和高电平1，synchronized通过有线程进入该方法就改变，传入的对象的状态来锁定一段代码，如有线程进入则改变对象的状态为1，其他进程过来时synchronized判断自己的对象为1则不让该线程进入，进入的线程执行结束后将对象的状态改为0，其他线程才可以进入。

package weiguoyuan.chainunicom.cn;

class Ticket extends Thread {
    private int tickets = 1000;
    private Object obj;
    public void run() {
        while(true){
            synchronized(obj) {//利用obj上锁
               if (tickets>0) {                       
                  System.out.println(Thread.currentThread().getName()+ " "+tickets--);
                }
            }
        }        
    }
}

public class TestThread {

    public static void main(String[] args) {
        Ticket t = new Ticket();
        t.start();
        t.start();
        t.start();
    }
}                                            

         第二种锁：synchronized 同步函数

package weiguoyuan.chainunicom.cn;

class Ticket extends Thread {
    private int tickets = 1000;
    public void run() {
        while(true){
           saleTickets();//原子性代码抽取成同步函数
        }        
    }
    public synchronized void saleTickets() {//这个谁调用synchronized  锁的就是谁 其实这3个线程都用的t这个对象调用该方法来同步
                     if (tickets>0) {                                       
　　　　　　　　　　　　　　 System.out.println(Thread.currentThread().getName()+ " "+tickets--);
    }
  }
}

public class TestThread {

    public static void main(String[] args) {
        Ticket t = new Ticket();
        t.start();
        t.start();
        t.start();
    }
} 

还可以用lock接口 主要用到的子类为ReentrantLock 来做同步（主要）有lock（）和 unlock（）方法 （finally 一定要执行的） 

11 死锁问题：比如两个线程 都是要得到磁盘和cpu才能运行，一个得到了磁盘，一个得到了cpu，都不释放资源，谁都运行不了

12 线程之间的通信，Thread类中有 sleep（）方法释放cpu和资源，Object类里有 wait（），notify()方法使当前线程等待和唤醒在此对象监视器上等待的单个线程，Object就是看成资源类（磁盘.notify()队列中一个等待的线程，这个线程就可以得到磁盘了）。