java 多线程

Posted 2020-09-25 米蓝

10

Java线程状态
NEW ---状态是指刚创建 , 尚未启动。
RUNNABLE --- 状态是正在正常中 , 当然可会有某时 /IO待的操作 /CPU时片切换 ,这个状态下发生的等待, 不是 , Sleep。
BLOCKED ---这个 个状态下 , 是在多个有同步操作的场景 , 比如正在待另一个的 synchronized 块的执放
WAITING --- 个状态下是指拥有了某个之后 , 用了他的 wait方法, 待其他 /拥有用 notify / notifyAll
TIMED_WAITING --- 个状态就是有的 (时制 )的WAITING, 一出现在用 wait(long), join(long)情况下 ,
另外一个 sleep后, 也会入 TIMED_WAITING状态
TERMINATED --- 个状态下 的 run方法已执完毕了 , 基本上就于死亡了。

线程的状态

 

首先新建一个线程，然后启动，启动后变成runnable状态，表示已经准备就绪可以执行了，或者正在执行当中。执行完了后终止。

blocked：访问临界区，如果拿不到临界区的资源，需要等待。被动的等待。

waiting：主动发起的等待。自己的数据没准备好。

timedwaiting：限时等待。跟waiting相似。这个有时间限制，比如设置5秒钟。不管5秒内数据有没有准备好，都执行。waiting是不限时间的等待。

线程的基本操作

        Thread t1 = new Thread(){   //新建线程
            @Override
            public void run(){
                System.out.println("hello");
            }
        };
        t1.start();  //启动线程，run方法被执行

Thread t1 = new Thread()；
t1.run();//在当前线程中执行。不是另外开启的线程。要想异步，必须start

不用重载run方法。使用Runable接口实现。

public class testRunable implements Runnable{
    public static void main(String[] args) {
        Thread t1 = new Thread(new testRunable()); //传入参数的模式。一般推荐
        t1.start();
    }
    @Override
    public void run() {
        System.out.println("OK");
    }
}

终止线程

Thread.stop();//不推荐使用。他会释放所有的monitor。有可能一个类中其他赋值还没有完成就停止了。这样就造成数据不同步，把对象写坏。会释放锁

中断线程，写一个支持中断的线程，可以有效的控制数据不被写坏。

t1.interrupt();//中断线程
Thread.currentThread().isInterrupted(); ///判断是否被中断
Thread.currentThread().interrupted();//判断是否被中断，并清除当前中断状态。

sleep 线程睡眠。释放cpu。抛出异常后，会清除中断标记位，所以需要在抛出异常的时候，再次中断。

    public void run() {
        // TODO Auto-generated method stub
        while(true){
            if(Thread.currentThread().isInterrupted()){ //线程被中断 退出
                break;
            }
            try {
                Thread.sleep(20000); //如果睡眠被中断，就会醒来
            }
            catch(InterruptedException e){  //抛出异常后，会清除中断标记位
                System.out.println("interrupted when sleep"); 
                Thread.currentThread().interrupt(); //设置中断  这样 当再次回到while循环的时候，就能判别有没有被中断。
                
            }
            Thread.yield();
        }
    }
}

挂起 suspend和 继续执行resume。这两个方法都是被废弃的。

suspend不会释放锁

如果枷锁发生resume之前，会发生死锁。

等待线程结束 join和谦让yeild

public class JoinMain {
    public volatile static int i = 0;
    public static class AddThread extends Thread {
        @Override
        public void run() {
            for (i = 0; i < 1000000; i++);
        }
    }
    public static void main(String[] args) throws InterruptedException {
        AddThread at = new AddThread();
        at.start();
        at.join(); //主线程停止执行，等待线程执行完，再打印i的值
        System.out.println(i);
    }
}

join的本质

while (isAlive()){ //判断当前线程还活着，当线程执行完毕后，系统会调用 notifyAll()
   wait(0); //调用wait方法
}
//不要在Thread实例上使用wait() 和notify（）方法 这样会干扰jdk内部实现。

synchronized 用来管理和控制临界区。

-给指定对象加锁：给指定对象加锁。进入同步代码前要获得给定对象的锁

-给实例方法加锁：相当于对实例加锁。进入同步代码前要获得当前实例的锁

-给静态放假加锁：相当于给当前类加锁。进入同步代码前要获得当前类的锁

public class SynchronizedTest extends Thread {
    public Object instance;
    public static int i;
    @Override
    public void run(){
        for(int j=0;j<100000;j++){
            //指定枷锁对象 一次只有一个线程
            synchronized(instance){
                i++;
            }
        }
    }
    //用在方法上  表示increase所在的对象上加锁  如果每次生成不同的实例，这个锁是没有用的
    public synchronized void increase(){
        i++;
    }
    // 表示给increase2 所在的类上加锁 。就算有不同的锁也可以锁住，因为类只有一个
    public static synchronized void increase2(){
        i++;
    }
}

public class Accounting implements Runnable {
    static Accounting instance = new Accounting();
    static int i=0;
    //锁加载Accounting类上  是可以锁住的
    public synchronized static void increase(){
        i++;
    }

//    锁加在instance实例上  也是可以锁住的  输出2000000
//    public synchronized  void increase(){
//        i++;
//    }

    @Override
    public void run() {
        for (int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(instance);
        Thread t2 = new Thread(instance);
        t1.start();t2.start();
        t1.join(); t2.join();
        System.out.println(i);  //运行结果，输出2000000      
    }
}

public class Accounting implements Runnable {
    static Accounting instance = new Accounting();
    static int i=0;
    //锁加在instance实例上 
    public  synchronized  void increase(){
        i++;
    }
    @Override
    public void run() {
        for (int j=0;j<1000000;j++){
            increase();
        }
    }
    public static void main(String[] args) throws InterruptedException{
        Thread t1 = new Thread(new Accounting());
 Thread t2 = new Thread(new Accounting());
        t1.start();t2.start();
        t1.join(); t2.join();
        System.out.println(i);  //因为初始化了不同的实例 所以是锁不住的  需要把increase 改成static
    }
}

Object.wait() 让线程等待。一般是数据没有准备好，所以等待

Object.notify() 通知在这个对象上等待的线程，可以继续工作了。不用再等待了。 如果有多个等待的线程，会随机先通知一个。

public class wnTest {
    public Object object = new Object();
    public class wn2 extends Thread {
        public void run(){
            synchronized(object){
                System.out.println(System.currentTimeMillis()+" :wn2 start!notify one thread");
                object.notify();
                System.out.println(System.currentTimeMillis()+" :wn2 end!");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public class wn1 extends Thread {
        public void run(){
            synchronized(object){
                System.out.println(System.currentTimeMillis()+" :wn1 start!");
                try {
                    System.out.println(System.currentTimeMillis()+" :wn1 wait for object");
                    object.wait();
                    
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis()+" :wn1 end!");
            }
        }
    }
    public void ext(){
        wn1 w = new wn1();
        wn2 w2 = new wn2();
        w.start();
        w2.start();
    }
    public static void main(String[] args) {
        new wnTest().ext();
    }
}

//执行结果
1498404259216 :wn1 start!
1498404259216 :wn1 wait for object
1498404259216 :wn2 start!notify one thread
1498404259216 :wn2 end!  
1498404261221 :wn1 end! //因为有个sleep操作，wn2不能马上执行完，导致wn1不能马上拿到锁。所以有时间差

线程安全

当多个线程对同一arraylist进行添加时，可能一个线程获取到的arraylist size为5 而另一个线程获取arrayList的size为3，当给arralist继续添加的时候，就会增加到第四个。但第四个已经被线程一添加过了。所以会抛出异常，而且获取的总是是小于预期的。

public class ArrayListMultiThread {
    static ArrayList<Integer> al = new ArrayList<Integer>(10);
    public static class AddThread implements Runnable{
        @Override
        public void run() {
            for (int i=0;i<1000;i++){
                al.add(i);
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new AddThread());
        Thread t2 = new Thread(new AddThread());
        t1.start();t2.start();
        t1.join(); t2.join();
        System.out.println(al.size()); //抛出异常 返回小于2000的数值。
    }
}

包装为线程安全的

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
public class safeArrayList {
    //将list变为线程安全的方法 对于所有的集合都是通用的
    static List<Integer> al = Collections.synchronizedList(new LinkedList<Integer>());
    public static List<String> l =   Collections.synchronizedList(new LinkedList<String>());
    public static List<String> l2 =   new Vector();
    public static List<String> l3=new CopyOnWriteArrayList<String>();
    public static class AddThread implements Runnable{
        @Override
        public void run() {
            for (int i=0;i<1000;i++){
                al.add(i);
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new AddThread());
        Thread t2 = new Thread(new AddThread());
        t1.start();t2.start();
        t1.join(); t2.join();
        System.out.println(al.size()); //2000
    }
}

    public static Map m= Collections.synchronizedMap(new HashMap()); 
    public static Map m2 = new ConcurrentHashMap();

ConcurrentHashMap的性能高于Collections.synchronizedMap。因为ConcurrentHashMap不是锁整个hashmap。而是把hashmap继续分成16个segments，每一个segments都是一个hashmap，每一次对它操作的时候，不需要锁整个对象，当有一个对象进来后，先锁整个对象，再查落在哪一个segments，然后锁单个segments就行。提高哦并发度。所以推荐。