java之旅之多线程编程

多线程编程

线程
线程的由来
单任务操作系统
一次执行一个应用
多任务OS
进程：每一个进程对应一个应用程序
每个应用分配独立内存，相互之间不干扰 CPU在他们之间来回切换
线程
一个进程内部的一个独立的执行分支
特点：共享内存地址空间
实现方式一
extends Thread 重写run方法，run方法只负责确定这个线程要做的事情。
开启线程:调用start方法–该方法会为线程分配资源，然后自动调用this.run()方法。
如果调用run方法，不会报错，但只是普通方法的调用，没有开启新线程。
实现方式二
实现runnable 接口 ，重写run方法。创建一个thread对象 ，把runnable 接口实现类对象传入 ，调用thrad 对象的start方法 。
同一个进程可以有很多线程
主线程（main线程）
子线程 地位和主线程一样
开始一定是主线程，结束不一定是主线程
GC垃圾回收线程
打印异常线程
死亡状态：线程run方法执行完毕，回收清理
运行状态：start 调用 run方法。
中断状态：在运行中由于种种原因，没有得到CPU 的执行，
原因：五种
由于CPU在执行其他线程，本线程没有得到执行
线程的优先级（共十级）。最高为10 ，最低为1。
优先级高的只是被执行的几率更大，不代表一定先执行完高的才会执行低的线程
由于I/O输入或输出的等待，造成该线程进入中断状态。我们叫阻塞 。scanner 阻塞完毕，继续抢CPU
休眠状态：主动调用Thread 的sleep方法 给一个毫秒数，休眠完毕，继续抢CPU
等待与唤醒机制：Object 的wait方法 等待方法 notify方法 唤醒方法 唤醒等待的第一个方法 。 notifyall 唤醒所有。
挂起：yield方法，强制让某个程序退出去。
就绪状态：调用start方法。但在start调用run之前
线程状态：新建状态： new Thread（）对象
线程安全（同步）synchronized
凡是线程安全的，效率都低
才会考虑线程安全性问题
锁机制，同步锁
一次只能执行一个线程，只有此线程执行完毕，下一个线程才能进入资源操作资源
当多个线程访问
同一个资源
的时候，有可能造成该资源数据混乱，为保证该资源每次只能被一个线程使用，使用完以后再交给下一个线程，我们要使用同步技术。
同步的第一种实现：同步方法
在资源身上加同步关键字synchronized
同步的第二种实现：同步块
在调用资源的线程身上使用关键字 synchronized
synchronized（this.rs）{
this.rs.show()；
}
包装类 所有包装类对象看起来传递的是引用，其实不是，传的是值 ，不像引用类型传的是引用。
死锁 两个线程依赖一对同步资源发生。
线程间通信 wait notify notifyall 让某个线程等待，一个线程执行完毕后 ，在唤醒
wait notify notifyall 必须在synchronized 里面调用
生产者与消费者
生产者线程
消费者线程

package com.lovo.syn;

/*
 * 当多个线程访问同一资源的时候，有可能造成该资源数据混乱.
 * 为保证该资源每次只能被一个线程使用，使用完以后再交给下一个
 * 线程，我们要使用同步技术
 */

//资源类
public class Resource {
    //资源方法
    /*
     * 同步的第一种实现：同步方法
     * 在资源身上加同步关键字synchronized
     */
//  public synchronized void show(String name){

    public void show(String name){
        for(int i = 0; i < 5; i++){
            System.out.println("线程" + name + "执行资源" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}

package com.lovo.syn;

public class SynThread extends Thread{

    private Resource rs;

    public SynThread(String name,Resource rs) {
        // TODO Auto-generated constructor stub
        this.rs = rs;
        this.setName(name);
        this.start();
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        /*
         * 同步的第二种实现：同步块
         * 在调用资源的线程身上使用synchronized
         */
        synchronized(this.rs){
            this.rs.show(this.getName());
        }

    }

}

package com.lovo.thread;

//线程的实现方式一：
//继承Thread类，重写run方法----run方法只负责确定这个线程要做的事情
//开启线程，要调用start方法----该方法会为线程分配资源，然后自动调用this.run()
//         如果调用run方法----不会报错，但只是普通的方法调用，没有开启新线程
public class MyThread extends Thread{

    private int num;

    public MyThread() {
        super();
        this.setPriority(Thread.MIN_PRIORITY);
        this.start();
    }

    public MyThread(int num) {
        super();
        this.num = num;
        this.start();//开启线程
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < 100; i++){
            System.out.println("MyThread " + num + "=============" + i);
        }
    }

}

package com.lovo.thread;

//线程实现方式二
//实现Runnable接口，重写run方法
//创建一个Thread对象，把Runnable接口的实现类对象传入
//调用Thread对象的start()
public class YourThread implements Runnable{

    private int num;

    public YourThread() {
        Thread th = new Thread(this);
        //线程优先级共十级，最高为10，最低为1
        //优先级高的只是被执行的几率更大，不代表完胜优先级底的
        th.setPriority(Thread.MAX_PRIORITY);
        th.start();
    }

    public YourThread(int num){
        this.num = num;
        Thread th = new Thread(this);
        th.start();
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        for(int i = 0; i < 100; i++){
            System.out.println("YourThread " + this.num + "=============" + i);
        }
    }

}

//生产者
public class Producer extends Thread{
    private Queue q;
    public Producer(Queue q){
        this.q = q;
    }

    public void run(){
        for(int i = 0; i < 10; i++){
            q.put(i);

        }
    }
}

//消费者
public class Customer extends Thread{
    private Queue q;
    public Customer(Queue q){
        this.q = q;
    }

    public void run(){
        for(int i = 0; i < 10; i++){
            int value = q.get();
        }
    }
}

package com.lovo.waitnotify;

//柜台
public class Queue {
    int value;
    boolean bFull = false;

    synchronized public void put(int i){
        if(bFull == false){
            value = i;
            bFull = true;
            System.out.println("producer put " + i);
            notify();
        }
        try{
            wait();
        }catch(Exception e){
            e.printStackTrace();
        }

    }

    synchronized public int get(){
        if(bFull == false){
            try{
                wait();
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        bFull = false;
        System.out.println("customer get " + value);
        notify();
        return value;
    }
}