java线程基础

线程的开启

• 继承Thread类，重写run()方法
  
  • 数据不共享

class MyThread extends Thread {     private int ticket = 5;    @Override    public void run() {    }}public class MyLearn {    public static void main(String[] args) throws Exception {        MyThread mt1 = new MyThread();         mt1.start();         MyThread mt2 = new MyThread();         mt2.start(); //两线程分别5个ticket    }}

• 实现Runnable接口，实现run()方法
  
  • 静态代理模式：
    
    1. Thread和MyThread都实现Runnable接口
    2. Thread作为代理，包含MyThread的引用
    3. 严格的代理设计模式之中应该是调用Thread.run(),而此处调用start()
  • 方便表示数据共享的概念

public class MyLearn {    public static void main(String[] args) throws Exception {        MyThread mt1 = new MyThread();         new Thread(mt1).start();        MyThread mt2 = new MyThread();         new Thread(mt2).start(); //两线程共享ticket    }}class MyThread implements Runnable {     private int ticket = 5;    @Override    public void run() {    }}

• 实现Callable接口，重写call()方法
  
  • 优点：call()方法可以抛异常并且可以带返回值，run()不可以

class MyThread implements Callable<String> {     @Override    public String call() throws Exception {        Thread.sleep(2000);        return "hello";    }}public class MyLearn {    public static void main(String[] args) throws Exception {        ExecutorService threadpool=Executors.newFixedThreadPool(1);        Future<String> future = threadpool.submit(new MyThread());        String s = future.get(); //主线程被阻塞，直到call()方法返回        System.out.println(s);        threadpool.shutdown();    }}

线程的停止

• stop() suspend()方法 已过时
• 标志位
  
  • volatile关键字：解决线程私有堆栈中数据和公共堆栈中的数据不同步
    

public class MyLearn {    public static void main(String[] args) throws Exception {        MyThread mt1 = new MyThread();         Thread thread = new Thread(mt1);        thread.start();        Thread.sleep(2000);//验证不加volatile时，不输出run end        mt1.stop();    }}class MyThread implements Runnable {     private int ticket = 5;    private volatile boolean flag=true; //volatile解决线程的可见性，并不能保证原子性    public void stop(){        flag=false;    }    @Override    public void run() {        while(flag){        }        System.out.println("run end");    }}

• 中断线程
  
  • 当线程处于阻塞态，标志位方法不好用，可以interrup()打破阻塞
  • public static boolean interrupted() 测试当前线程是否中断并清除中断状态
  • public boolean isInterrupted() 测试线程是否中断，不影响线程的状态；

public class MyLearn {    public static void main(String[] args) throws Exception {        MyThread mt1 = new MyThread();        Thread thread = new Thread(mt1);        thread.start();        int num = 0;        while (true) {            Thread.sleep(500);            num++;            if ( num== 3) {                mt1.setFlag(false);                thread.interrupt();                break;            }        }    }}class MyThread implements Runnable {    private int ticket = 5;    private volatile boolean flag = true;    public void setFlag(boolean f){    this.flag=f;}    @Override    public void run() {        while (flag) {            try {                Thread.sleep(3500);            } catch (InterruptedException e) {                System.out.println("over");                //e.printStackTrace();            }        }    }}

class MyThread implements Runnable  {    private int ticket = 5;    @Override    public void run() {         for(int j=0;j<500000;j++){             System.out.println("j="+j);             if(Thread.currentThread().interrupted()){                 try {                    throw new InterruptedException("thread is interrupted");                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                    break;                  }             }         }    }}

线程的阻塞

• public static void sleep(long millis) throws InterruptedException
  
  • 阻塞当前线程，不释放锁，睡醒后进入就绪状态
  • 捕获InterruptedException
• public static void yield()
  
  • 当前线程进入就绪态，不抛出异常
  • 把机会让给相同或者更高优先级的线程，重新争夺
• public void join()
  
  • 在当前线程中调用另一个线程的join()方法，当前线程转入阻塞状态，直到另一个线程结束，当前线程再由阻塞转为就绪状态。
• public void wait()
  
  • 属于Object类的方法，在同步方法或同步块中使用，释放锁
  • 使当前拥有对象锁的线程等待，直到其他线程调用notify()
• synchronized
  
  • 多线程访问同一份资源，保证线程安全，同步粒度太小易造成死锁
  • 同步方法； 同步代码块 (引用类型，this，类.class)

线程的状态

线程的信息

• public Thread(Runnable target, String name)；
• public final void setName(String name)；
• public final String getName()；
• public static Thread currentThread()
• public final void setPriority(int newPriority)；
• public final int getPriority()；
• public final boolean isAlive ();
• public final boolean isDaemon(): //是否是守护线程
• public void setDaemon(boolean on) //在start()方法调用前设置

线程的同步

• synchronized
  
  • 当一个线程访问object的一个synchronized时，另一个线程仍然可以访问该object中的非synchronized
  • synchronized关键字不能继承
• 生产者消费者模式解决死锁：wait()/notify()

public class MyLearn {    public static void main(String[] args) throws Exception {        burgerStack bs=new burgerStack();        producer p=new producer(bs);        consumer c=new consumer(bs);        Thread tp=new Thread(p);        Thread tc=new Thread(c);        tp.start();        tc.start();    }}class producer implements Runnable {    burgerStack bs=null;    public producer(burgerStack bs) {        super();        this.bs = bs;    }    @Override    public void run() {        for(int i=0;i<20;i++){            burger b=new burger(i);            bs.push(b);            System.out.println("produce"+b.id);        }    }}class consumer implements Runnable{    burgerStack bs=null;    public consumer(burgerStack bs) {        super();        this.bs = bs;    }    @Override    public void run() {        for(int i=0;i<20;i++){            burger b=bs.pop();            System.out.println("consume"+b.id);        }    }}class burger {    int id;    public burger(int id) {        this.id = id;    }}class burgerStack {    burger[] burgerArr = new burger[6];    int index = 0;    public synchronized void push(burger in) {        while(index==burgerArr.length){ //用while而非if防中断跳出if            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        this.notify();        burgerArr[index] = in;        index++;    }    public synchronized burger pop() {        while(index==0){            try {                this.wait();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        this.notify();        index--;        return burgerArr[index];    }}