【知识点整理（Java）】Java Thread 简单使用注意点汇总（一）

Java Thread简单使用注意点汇总（一）

一、实现多线程的方式：继承Thread类或者实现Runable方法。

二、Thread类的run和start方法的区别：

run()称为线程体，调用run()方法，方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码； 程序中只有主线程。

start()方法来启动线程，真正实现了多线程运行。

三、多线程的运行状态：线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。

具体情况有：TODO 补充

四、多线程获取当前运行线程对象和名称

Thread.currentThread()/this;

getName() 获取名称，setName()/Thread(String name) 设置线程名称

注意：run方法中局部变量在不同线程中单独开辟不同的内存空间。局部变量不相同。

五、synchronized 关键词

声明Object类中的monitor开启使用。Monitor含义是监视器，锁。
所分等级，类锁和对象锁。

A、对象锁

同步代码块：

Object obj = new Object();
synchronized(obj){ 
//使用obj的monitor，实现互斥量的作用（synchronized使用原理非临界区）
//对共享变量的使用  
}

同步方法：

synchronized void do(){
}

相当于

synchronized(this){}

B、类锁

同步代码块：

synchronized(Single.class){ //使用obj的monitor，实现互斥量的作用（synchronized使用原理非临界区）
//对共享变量的使用  
}

静态同步方法：

synchronized static void do(){
}

C、关于锁的控制

以上的锁是自动控制即synchronized修饰的代码运行完，自动释放锁。
可以通过wait，notify控制锁的加锁和释放。

六、单例模式设计（随着需求增加而改变）

单线程：

public class SimpleSingle {

    private static final SimpleSingle single = new      SimpleSingle();

    private SimpleSingle() {
    }

    public static SimpleSingle getInstance() {
        return single;
    }
}

考虑多线程同步问题：

public class SimpleSingle {

    private static final SimpleSingle single = null;

    private SimpleSingle() {
    }

    public static synchronized SimpleSingle getInstance() {

        if(single==null){
            single = new SimpleSingle();
}
        return single;
    }
}

考虑多线程同步问题，同时考虑效率问题。

public class SimpleSingle {

    private static final SimpleSingle single = null;

    private SimpleSingle() {
    }

    public static SimpleSingle getInstance() {

        if(single==null){
            synchronized(SimpleSingle.class){
                if(single==null){
                     single = new SimpleSingle();
                }
            }
        }
        return single;
    }
}

当然还有静态内部类，枚举类等方式。

七、死锁

出现：同步中出现嵌套同步

public class DeadLock {

    public static void main(String[] args) {

        Thread thread1 = new Thread(new MyRunable(true));
        Thread thread2 = new Thread(new MyRunable(false));

        thread1.start();
        thread2.start();
    }
}
class MyRunable implements Runnable {

    boolean flag;
    Object lockA = new Object();
    Object lockB = new Object();

    public MyRunable(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {

        if (flag) {
            synchronized (lockA) {

                System.out.println("true 获得锁A");

                synchronized (lockB) {
                    System.out.println("true 获得锁B");
                }
            }
        } else {
            synchronized (lockB) {

                System.out.println("true 获得锁B");

                synchronized (lockA) {
                    System.out.println("true 获得锁A");
                }
            }
        }
    }
}