线程基本知识

2019-12-20  本文已影响0人  越走越远的风

进程与线程的区别

线程的状态及其相互转换

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE):处于可运行状态的线程正在JVM中执行，但它可能正在等待来自操作系统的其他资源，例如处理器。
阻塞(BLOCKED)：线程阻塞于synchronized锁，等待获取synchronized锁的状态。
等待(WAITING)：Object.wait()、join()、 LockSupport.park(),进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIME_WAITING)：Object.wait(long)、Thread.join()、LockSupport.parkNanos()、LockSupport.parkUntil，该状态不同于WAITING，它可以在指定的时间内自行返回。
终止(TERMINATED)：表示该线程已经执行完毕自己结束，或者产生了异常而结束。

创建线程的方式

什么是线程安全性

当多个线程访问某个类,不管运行时环境采用何种调度方式或者这些线程如何交替执行,并且在主调代码中不需要任何额外的同步或协同,这个类都能表现出正确的行为,那么就称这个类为线程安全的。----《并发编程实战》

原子性操作

一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
volatile关键字仅仅保证可见性，并不保证原子性 ​ synchronize关机字，使得操作具有原子性。

synchronized关键字

每个java对象都可以用做一个实现同步的锁，这些锁称为内置锁。线程进入同步代码块或方法的时候会自动获得该锁，在退出同步代码块或方法时会释放该锁。获得内置锁的唯一途径就是进入这个锁的保护的同步代码块或方法。

内置锁是一个互斥锁，这就是意味着最多只有一个线程能够获得该锁，当线程A尝试去获得线程B持有的内置锁时，线程A必须等待或者阻塞，直到线程B释放这个锁，如果B线程不释放这个锁，那么A线程将永远等待下去。

//放在方法 锁得是对象 和 synchronized(this)是一样的
    public synchronized void lockMethod(){
        System.out.println(Thread.currentThread().getName()+" lockMethod");
    }
    
    public void lockMethod_CodeBlockByThis() {
        //代码块 this锁的是对象
        synchronized(this) {
            System.out.println(Thread.currentThread().getName()+" lockMethod_CodeBlockByThis");
        }
    }

    //类锁
    public void lockMethod_CodeBlockByClass() {
        //代码块 Class锁的是类，无论任何地方，任何类只要是锁的是同一个class，并发时都会等待
        synchronized(ThreadDemo.class) {
            System.out.println(Thread.currentThread().getName()+"lockMethod_CodeBlockByClass");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //放在静态方法上，锁的是当前的class，此处的锁和synchronized(ClassA.class)是同样的
    public synchronized static void lockStaticMethod() {
        System.out.println(Thread.currentThread().getName()+" lockStaticMethod");

    }

volatile关键字及其使用场景

指令重排：CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化，在某些情况下，这种优化会带来一些执行的逻辑问题，主要的原因是代码逻辑之间是存在一定的先后顺序，在并发执行情况下，会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。

单例与线程安全

public class HungerSingleton {

    private static HungerSingleton ourInstance = new HungerSingleton();

    public static HungerSingleton getInstance() {
        return ourInstance;
    }

    private HungerSingleton() {
    }

}

public class LazySingleton {

    private static volatile LazySingleton ourInstance = null;

    public static LazySingleton getInstance() {
        if(null == ourInstance){
            synchronized (ourInstance){
                if(ourInstance == null){
                    ourInstance = new LazySingleton();
                }
            }
        }
        return ourInstance;
    }

    private LazySingleton() {
    }
}

如何保证单例？
private私有的空参构造器
static的对象和方法getInstance

如何避免线程安全性问题

上一篇下一篇

猜你喜欢

热点阅读