Java随笔（线程）

线程

进程的执行单元，线程可以拥有自己的堆栈、自己的程序计数器和局部变量，但不拥有系统资源，它与父进程的其他线程共享进程所拥有的的全部资源。

线程的创建

1.继承Thread
2.实现Runnable接口
3.使用Callable和Future接口。
Callable提供call方法，类似于Runnable接口的run方法，但更强大，原因
1.call()可以有返回值。
2.call()方法可以声明抛出异常。
创建实现Callable接口的线程过程：
（1）创建Callable接口的实现类
（2）使用FutureTask类包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法。
（3）使用FutureTask对象作为Thread对象的target创建并启动新线程。
（4）调用FutureTask对象的get()方法来获得子线程执行结束的返回值。
例：

import java.util.concurrent.Callable;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

public class CallableThread {
    public static void main(String[] args) {
       try{
           CallableThread ct=new CallableThread();
           FutureTask<Integer> task=new FutureTask<>((Callable<Integer>)()->
           {
               int i=0;
               for (; i <100 ; i++) {
                   System.out.println(Thread.currentThread().getName()+" "+i);
               }
               return i;//Call方法可以由返回值
           });
           for (int i = 0; i <100 ; i++) {
               System.out.println(Thread.currentThread().getName()+" "+i);
               if(i==20){
                   new Thread(task,"hhh建立的进程").start();
               }
           }
       }catch(Exception e){
           e.printStackTrace();
       }finally {
           System.out.println(task.get());
       }
    }
}

线程的生命周期

sleep和yield的区别

1.执行sleep()的线程进入阻塞状态，在其睡眠时间段内，即使系统中没有可以执行的线程，该线程也不会获得执行的机会。
2.执行yield()的线程进入就绪状态，即让该线程暂停一下，让系统的线程调度重新调度一次，只有优先级与当前线程的优先级相同或者比当前优先级更高的处于就绪状态的线程才会获得执行机会，可能出现的情况是，调用yield()的线程又被线程调度器调度，重新执行。

线程同步

（1）同步代码块

（2）同步方法

（3）同步锁

线程通信

使用同步方法或同步块的线程通信

对于使用synchronized修饰的同步方法（this指向调用该方法的对象）或者同步代码块（this指向括号里的对象），线程间通信可以直接使用：wait()、notify()、notifyall()。
（1）wait():导致当前线程等待，知道其他线程调用该同步监视器的notify()方法或者notifyAll()方法来唤醒该进程。
（2）notify():唤醒在此同步监视器上等待的单个线程，随机性。
（3）notifyAll():唤醒在此同步监视器上等待的所有线程。

使用同步锁的线程通信

对于使用同步锁（Lock）的线程，线程中不存在隐式的同步监视器，也就不能使用wait()、notify()、notifyall()，Java提供了一个Condition类来协调。Condition实例被绑定在一个Lock对象上，要获得特定Lock实例的Condition实例，调用Lock对象的newCondition()方法即可，Condition提供如下三种方法：
（1）await():类似于wait
（2）signal():类似于notify()。
（3）siginalAll():类似于notifyAll()

public class Account {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();//Condition绑定Lock
    private String accountNo;
    private double balance;
    private boolean flag = false;//true=>have money

    public Account() { } ;
    public Account(String accountNo, double balance) {
        this.accountNo = accountNo;
        this.balance = balance;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public String getAccountNo() {
        return accountNo;
    }

    public void setAccountNo(String accountNo) {
        this.accountNo = accountNo;
    }

    public void draw(double balance) {
        lock.lock();
        try {
            if (!flag) {
                condition.await();//当前进程等待
            } else {
                System.out.println(Thread.currentThread().getName() + " 取钱" + balance);
                this.balance -= balance;
                System.out.println("余额 ："+balance);
                flag=true;
                condition.signalAll();//唤醒其他进程
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void deposit(double depositAmount){
        lock.lock();
        try{
            if(flag){
                condition.await();
            }
            else {
                System.out.println(Thread.currentThread().getName()+" 存钱"+depositAmount);
                balance+=depositAmount;
                System.out.println("余额 ："+balance);
                flag=true;
                condition.signalAll();
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

使用BlockingQueue进行线程通信

BlockingQueue（阻塞队列）重点：
（1）put(E e):尝试把E元素放入BlockingQueue，如果队满，阻塞该线程。
（2）take(E e):尝试从BlockingQueue的头取出元素，如果队列元素空，阻塞该线程。’

	抛出异常	不同返回值	阻塞进程	指定超时时长
队尾插入元素	add(e)	offer(e)	put(e)	offer(e,time,unit)
队头删除元素	remove(e)	poll(e)	take(e)	poll(time,unti)
获取、不删除元素	element()	peek()	无	无

示例：写两个线程，其中一个线程打印1~52，另一个线程打印A ~Z，打印顺序是12A34B56C……5152Z
代码如下:

//打印数字的线程
public class PrintNumber extends Thread {
    private BlockingQueue<Integer> bq;
    private int start;
    private int end;
    public PrintNumber(BlockingQueue<Integer> bq,int start,int end){
        this.bq=bq;
        this.start=start;
        this.end=end;
    }

    @Override
    public void run() {
        try{
            for(int i=start;i<=end;i++){
                bq.put(i);
                System.out.println(i);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

//打印字母的线程
public class PrintLetter extends Thread {
    private BlockingQueue<Integer> bq;
    private char start;
    private char end;
    public PrintLetter(BlockingQueue bq,char start,char end){
        this.bq=bq;
        this.start=start;
        this.end=end;
    }

    @Override
    public void run() {
       try{
           for (int i = (int)start; i <=(int)end ; i++) {
               bq.take();
               bq.take();
               System.out.println((char)i);
           }
       }catch (InterruptedException e){
           e.printStackTrace();
       }
    }
}

//main函数

public class Test {
    public static void main(String[] args) {
        BlockingQueue<Integer> bq=new ArrayBlockingQueue<>(2);
        new PrintNumber(bq,1,52).start();
        new PrintLetter(bq,'A','Z').start();


    }
}