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");
    }
}