java多线程总结

Posted 2020-11-28 yinchh

线程状态

• Runnable
• Blocked
  sleep、join、wait、synchronized 四个关键字都会使线程进入Blocked状态
• Running
• Dead

synchronized关键字

• Object类有两个监视器相关的方法wait、notify
• synchronized和wait、notify同时使用，wait、notify必须在synchronized中
• synchronized(obj)同步代码块使用obj对象的监视器实现同步
• 实例方法使用synchronized锁定的是当前实例
• 静态方法使用synchronized锁定的是当前类的所有实例

synchronized关键字实现多线程同步

public class TestSynchronized {
    public static void main(String[] args) throws InterruptedException {
        Test test = new Test();
        List<Thread> listThread = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 100; j++) {
                        test.Increase();
                    }
                }
            });
            listThread.add(thread);
            thread.start();
        }
        // 主线程等待所有子线程执行完成
        for (Thread t : listThread) {
            t.join();
        }
        test.print();
    }
}
class Test {
    int i = 0;

    public synchronized void Increase() {
        i++;
    }
    public void print() {
        System.out.println(i);
    }
}

synchronized配合wait、notify实现生产者消费者

public class ProducerConsumer {

    public static void main(String[] args) {
        ProCon proCon = new ProCon();
        
        //生产者
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    for (int i = 0; i < 20; i++) {
                        proCon.pro(i);
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                }
            }
        }).start();
        
        //消费者1
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        proCon.con();
                        Thread.sleep(3000);
                    }
                } catch (InterruptedException e) {
                }
            }
        }).start();

        //消费者2
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        proCon.con();
                        Thread.sleep(3000);
                    }
                } catch (InterruptedException e) {
                }
            }
        }).start();
    }

}

class ProCon {
    List<Integer> listProduct = new ArrayList<Integer>();

    public synchronized void pro(int pro) throws InterruptedException {
        if (listProduct.size() > 100) {
            System.out.println(getPrefix() + "库存已满，请稍候再生产");
            wait();
        }

        listProduct.add(pro);
        System.out.println(getPrefix() + "生产了:" + pro);
        notifyAll();// 通知消费者获取产品
    }

    public synchronized void con() throws InterruptedException {
        if (listProduct.size() <= 0) {
            System.out.println(getPrefix() + "库存不足，请及时补货");
            wait();
        }

        Integer cur = listProduct.get(0);
        listProduct.remove(cur);
        System.out.println(getPrefix() + "取走:" + cur + " 剩余库存：" + listProduct.toString());
        notifyAll();// 通知生产者生产产品
    }

    private String getPrefix() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()) + Thread.currentThread().getName() + " ";
    }
}

volatile关键字

多线程的内存模型：main memory（主存）、working memory（线程栈），线程处理数据时，先把主存中的数据load到本地栈，操作完成后会save回主存，volatile关键词的作用：每次针对该变量的操作都激发一次load and save。
针对多线程使用的变量如果不是volatile或者final修饰的，很有可能产生不可预知的结果（另一个线程修改了这个值，但是之后在某线程看到的是修改之前的值）。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的，本质上，volatile就是不去缓存，直接取值。在线程安全的情况下加volatile会牺牲性能。

多线程实现

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestThread {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 1、继承Thread类，资源和Thread绑定，资源无法共享
        new Thread1().start();
        new Thread1().start();

        // 2、实现Runnable接口，资源和Runnable接口绑定，资源可以共享
        Thread2 thread2 = new Thread2();
        new Thread(thread2).start();
        new Thread(thread2).start();

        // 3、实现Callable<>接口
        ExecutorService e = Executors.newFixedThreadPool(3);
        Future future = e.submit(new Thread3());
        // future.isDone(); // return true,false 无阻塞
        String str = (String) future.get(); // return 返回值，阻塞直到该线程运行结束
        System.out.println("主线程结束");
        System.out.println(str);
    }
}

// 1、继承Thread类
class Thread1 extends Thread {
    int i = 0;

    @Override
    public void run() {
        i++;
        System.out.println(i);
    }
}

// 2、实现Runnable接口
class Thread2 implements Runnable {
    int i = 0;

    @Override
    public void run() {
        i++;
        System.out.println(i);
    }
}

// 3、实现Callable<>泛型接口
// 可以在任务结束后提供一个返回值，Runnable不行
// call方法可以抛出异常，Runnable的run方法不行
// 可以通过运行Callable得到的Fulture对象监听目标线程调用call方法的结果，得到返回值，（fulture.get(),调用后会阻塞，直到获取到返回值）
class Thread3 implements Callable<String> {

    @Override
    public String call() throws Exception {
        Thread.sleep(3000);
        System.out.println("子线程结束");
        return "test";
    }
}

多线程控制类

1. ThreadLocal
   保存线程的独立变量。对一个线程类（继承自Thread)
   当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。常用于用户登录控制，如记录session信息。
   实现：每个Thread都持有一个TreadLocalMap类型的变量（该类是一个轻量级的Map，功能与map一样，区别是桶里放的是entry而不是entry的链表。功能还是一个map。）以本身为key，以目标为value。
   主要方法是get()和set(T a)，set之后在map里维护一个threadLocal -> a，get时将a返回。ThreadLocal是一个特殊的容器。

未完待续。。。