Java中的多线程常用方法

多线程一直是Java的一个重点和难点，前两天小结了一下。

synchronized和Lock

我们都知道ArrayList是非线程安全的，就拿它开刀。下面这个程序简单地展示了synchronized和Lock的用法。

package temp.test;import java.util.ArrayList;import java.util.List;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * Created by 10033 on 2017/5/10. */public class ArrayListThreadTest {    public static Lock lock=new ReentrantLock();    public static List list=new ArrayList();    public static int doRun(int cou) {        while(cou<100000) {            //非同步方法 要么死循环 要么抛异常            /*list.add(10);            ++cou;*/            //两种同步方式            /*synchronized (list) {                list.add(10);                ++cou;            }*/            lock.lock();            list.add(10);            ++cou;            lock.unlock();        }        return cou;    }    public static void main(String[] args) {        Thread1 thread1=new Thread1();        Thread2 thread2=new Thread2();        thread1.start();        thread2.start();        while(thread1.cou+thread2.cou<200000) {            System.out.println(thread1.cou+thread2.cou);        }        System.out.println(list.size() + " @@@@");        System.out.println(thread1.cou+thread2.cou + " ####");    }}class Thread1 extends Thread {    public int cou=0;    @Override    public void run() {        this.cou=ArrayListThreadTest.doRun(cou);    }}class Thread2 extends Thread {    public int cou=0;    @Override    public synchronized void run() {        this.cou=ArrayListThreadTest.doRun(cou);    }}

如果不用同步，那么这个程序要么死循环，要么抛数组下标溢出异常。

tryLock

package temp.test;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * Created by 10033 on 2017/5/10. */public class LockTest {    public static Lock lock=new ReentrantLock();    public static void main(String[] args) {        new Thread(new Runnable() {            public void run() {                boolean flag=false;                try {                    Thread.sleep(3000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                try {//                    if(lock.tryLock(1, TimeUnit.SECONDS)) { //设置时间来获得锁 超时则放弃                    if(lock.tryLock()) { //第一次没得到就放弃                        flag=true;                    } else {                        System.out.println("没获得锁");                    }                } catch (Exception e) {                    e.printStackTrace();                } finally {                    if(flag) { //确定锁上了才解锁                        lock.unlock();                        System.out.println("解锁啦");                    }                }            }        }).start();        new Thread(new Runnable() {            public void run() {                lock.lock();                try {                    Thread.sleep(3000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println("解锁~~~~");                lock.unlock();            }        }).start();    }}

lock和tryLock的一个不同是lock是阻塞等待锁资源，而tryLock则是试一试(和它名字一样)，如果不行，就放弃。

lockInterruptibly

package temp.test;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * Created by 10033 on 2017/5/11. */public class LockInterruptiblyTest {    public static Lock lock=new ReentrantLock();    public static void main(String[] args) throws InterruptedException {        Thread t1=new Thread(new Runnable(){            @Override            public void run() {                try {//                    Thread.sleep(3000);                    lock.lockInterruptibly();                    System.out.println("No Exeception");                    while(true);//                    for(int i=0;i<1000000;i++);                } catch (InterruptedException e) {                    e.printStackTrace();                    System.out.println(Thread.currentThread().getName()+" interrupted.");                } finally {                    lock.unlock();                }            }        });        t1.start();        t1.interrupt();//中断则锁抛异常//        Thread.sleep(1000);    }}

这个和lock一样也是个愣头青，阻塞等待锁，但它所在的线程一旦收到中断信号，它就抛异常。

interrupt

说到中断，那就讲一下interrupt。

package temp.test;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * Created by 10033 on 2017/5/11. */public class InterruptTest {    public static String lock="";    public static Lock locked=new ReentrantLock();    public static Condition condition=locked.newCondition();    public static void main(String[] args) throws InterruptedException {        Thread t1=new Thread(new Runnable() {            @Override            public void run() {                /*synchronized (lock) {                    for(int i=0;i<10;i++)                        System.out.println("@@");                    try {                        lock.wait();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    for(int i=0;i<10;i++)                        System.out.println("##");                }*/                locked.lock();                for(int i=0;i<10;i++)                    System.out.println("@@");                try {                    condition.await();                } catch (InterruptedException e) {                    e.printStackTrace();                }                for(int i=0;i<10;i++)                    System.out.println("##");                locked.unlock();            }        });        t1.start();        Thread.sleep(1000);        t1.interrupt();//唤醒阻塞但抛中断异常        /*synchronized (lock) { //唤醒阻塞不抛异常 wait会主动放弃锁资源            lock.notify();        }*/        /*locked.lock();        condition.signal();        locked.unlock();*/            }}

它就是改变一个状态值，它能唤醒阻塞线程（被sleep和wait的），但会抛中断异常。这里还要说一点，那就是wait和notify方法都得在使用该方法的对象的synchronized同步代码块里使用。如：

signal和await

我们都知道Object有wait，notify，notifyAll三个方法，而在Lock机制里，同样有对应的await，signal，signalAll。

package temp.test;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/** * Created by 10033 on 2017/5/10. *//** * await和signal必须放在lock之后 */public class SignalAndAwait {    public static Lock lock=new ReentrantLock();    //两个Condition来自同一把锁    public static Condition condition1=lock.newCondition();    public static Condition condition2=lock.newCondition();    public static void main(String[] args) {        new Thread(new Runnable() {            public void run() {                for(int i=0;i<50;i++) {                    lock.lock();                    condition2.signal();                    System.out.println("Thread1");                    try {                        condition1.await();                    } catch (InterruptedException e) {                        e.printStackTrace();                    } finally {                        lock.unlock();                    }                }                lock.lock();                condition2.signal();                lock.unlock();            }        }).start();        new Thread(new Runnable() {            public void run() {                for(int i=0;i<50;i++) {                    lock.lock();                    condition1.signal();                    System.out.println("Thread2");                    try {                        condition2.await();                    } catch (InterruptedException e) {                        e.printStackTrace();                    } finally {                        lock.unlock();                    }                }                lock.lock();                condition1.signal();                lock.unlock();            }        }).start();    }}

这三个方法也必须放在它们对应的lock里执行，即获得锁资源后才能执行，不然会抛异常。

yield和join

yield：将当前线程由运行变为就绪。

join：阻塞当前线程，自己开启的线程先运行完再说。

可以看注释，注释写得比较详细

YieldTest

package threadTest;/** * Created by 10033 on 2017/5/19. */public class YieldTest {    public static void main(String[] args) {        new Thread(new T1()).start();        new Thread(new T2()).start();    }}class T1 implements Runnable {    @Override    public void run() {        System.out.println("T1~~~~~");        Thread.yield();     //从运行到就绪  如果对方线程不争气阻塞了 那我也不客气 接着运行        System.out.println("T1@@@@@");    }}class T2 implements Runnable {    @Override    public void run() {        System.out.println("T266666");        try {            Thread.sleep(5000);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("T2T2T2");    }}

JoinTest

package threadTest;/** * Created by 10033 on 2017/5/19. */public class JoinTest {    public static void main(String[] args) throws InterruptedException {        /*Thread t2=new Thread(new T4());//        t2.join(); //放在start之前并不会抛异常 但没join效果        t2.start();        t2.join(); //我加入了我就是老大  等我运行完后面的程序才能运行        new Thread(new T3()).start();*/        new Thread(new T3()).start(); //内部有join 说明join只影响当前线程        new Thread(new T4()).start();    }}class T3 implements Runnable {    @Override    public void run() {        System.out.println("T1~~~~~");        System.out.println("T1@@@@@");    }}class T4 implements Runnable {    @Override    public void run() {        System.out.println("T266666");        Thread t=new Thread() {            @Override            public void run() {                try {                    Thread.sleep(5000);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println("success");            }        };        t.start();        try {            t.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        /*try {            Thread.sleep(5000);        } catch (InterruptedException e) {            e.printStackTrace();        }*/        System.out.println("T2T2T2");    }}