多线程与同步代码块详解

线程是程序执行的一条路径，一个进程中可以包含多条线程。多线程并发执行可以提高程序的效率，可以同时完成多项工作，多线程并发执行的实质就是CPU在做着高速的切换。多线程的应用场景：红蜘蛛同时共享屏幕给多个电脑；迅雷开启多条线程一起下载；QQ同时和多个人一起视频；服务器同时处理多个客户端请求。

并行和并发的区别

并行就是两个任务同时运行，就是甲任务进行的同时，乙任务也在进行。(需要多核CPU)
并发是指两个任务都请求运行，而处理器只能按受一个任务，就把这两个任务安排轮流进行，由于时间间隔较短，使人感觉两个任务都在运行。
比如我跟两个网友聊天，左手操作一个电脑跟甲聊，同时右手用另一台电脑跟乙聊天，这就叫并行。如果用一台电脑我先给甲发个消息，然后立刻再给乙发消息，然后再跟甲聊，再跟乙聊。这就叫并发。

Java程序运行原理

Java命令会启动java虚拟机，启动JVM，等于启动了一个应用程序，也就是启动了一个进程。该进程会自动启动一个 “主线程” ，然后主线程去调用某个类的 main 方法。JVM启动至少启动了垃圾回收线程和主线程，所以是多线程的。

代码验证：

public class Demo1_Thread {  //此程序的运行结果是 "我是主线程的执行代码"和"垃圾被清扫了"交替执行/**证明jvm是多线程的*/public static void main(String[] args) {for(int i = 0; i < 100000; i++) {new Demo();}for(int i = 0; i < 10000; i++) {System.out.println("我是主线程的执行代码");}}
}class Demo {@Overridepublic void finalize() {System.out.println("垃圾被清扫了");}}

多线程的实现

方式一：定义类继承Thread，重写run方法，把新线程要做的事写在run方法中；创建线程对象，开启（调用start()）新线程, 内部会自动执行run方法。

代码演示：

public class Demo2_Thread {public static void main(String[] args) {MyThread mt = new MyThread();        //4,创建Thread类的子类对象mt.start();               //5,开启线程MyThread mt1 = new MyThread();mt1.start();for(int i = 0; i < 1000; i++) {System.out.println("bb");}}}
class MyThread extends Thread {     //1,继承Threadpublic void run() {             //2,重写run方法for(int i = 0; i < 1000; i++) {        //3,将要执行的代码写在run方法中System.out.println("aaaaaaaaaaaa");}}
}

方式二：定义类实现Runnable接口，实现run方法，把新线程要做的事写在run方法中，创建自定义的Runnable的子类对象，创建Thread对象，传入Runnable，调用start()开启新线程，内部会自动调用Runnable的run()方法。

代码演示：

public class Demo3_Thread {public static void main(String[] args) {MyRunnable mr = new MyRunnable();    //4,创建Runnable的子类对象Thread t = new Thread(mr);      //5,将其当作参数传递给Thread的构造函数t.start();              //6,开启线程for(int i = 0; i < 1000; i++) {System.out.println("bb");}}}
class MyRunnable implements Runnable {          //1,定义一个类实现Runnable@Overridepublic void run() {                //2,重写run方法for(int i = 0; i < 1000; i++) {        //3,将要执行的代码写在run方法中System.out.println("aaaaaaaaaaaa");}}}

剖析实现Runnable接口的源码

源码解释：构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断成员变量Runnable的引用是否为空，不为空编译时看的是Runnable的run()，运行时执行的是子类的run()方法。

源码解析：

public class Thread implements Runnable {    //Thread类本身实现了Runnable接口/*省略代码*/private Runnable target;    //一个Runnable类型的成员变量public Thread(Runnable target) {//Thread的有参构造方法，传入一个Runnable接口的子类对象target//调用init方法（下面这个） 把target传入init(null, target, "Thread-" + nextThreadNum(), 0);}private void init(ThreadGroup g, Runnable target, String name, long stackSize) {  //init方法里面又调用另一个重载的init方法（下面这个）把target传入init(g, target, name, stackSize, null);       }private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc) {/*省略代码*/this.target = target;//在init方法里面把成员变量target 进行赋值/*省略代码*/}public synchronized void start() { //当调用start方法的时候 内部调用的是start0()方法/*省略代码*/start0();/*省略代码*/}private native void start0(); //start0()是native修饰的方法 底层是其他语言 我们无法查看，但是我们知道底层会调用run方法@Overridepublic void run() {      //start0()的底层是会调用run()方法if (target != null) {  //判断成员变量target是否为nulltarget.run();  //如果target被赋值了，就要调用target的run方法}}/*省略代码*/
}

多线程两种实现方式的区别

继承Thread : 由于子类重写了Thread类的run()，当调用start()时, 直接找子类的run()方法；好处是:可以直接使用Thread类中的方法,代码简单；弊端是:如果已经有了父类，就不能用这种方法。

实现Runnable : 构造函数中传入了Runnable的引用, 成员变量记住了它, start()调用run()方法时内部判断成员变量Runnable的引用是否为空, 不为空编译时看的是Runnable的run()，运行时执行的是子类的run()方法。好处是:即使自己定义的线程类有了父类也没关系，因为有了父类也可以实现接口，而且接口是可以多实现的；弊端是:不能直接使用Thread中的方法需要先获取到线程对象后，才能得到Thread的方法，代码复杂。

匿名内部类实现线程的两种方式

public static void main(String[] args) {new Thread() {                               //1,继承Thread类public void run() {                        //2,重写run方法for(int i = 0; i < 1000; i++) {        //3,将要执行的代码写在run方法中System.out.println("aaaaaaaaaaaaaa");}}}.start();                                  //4,开启线程new Thread(new Runnable() {                 //1,将Runnable的子类对象传递给Thread的构造方法public void run() {                     //2,重写run方法for(int i = 0; i < 1000; i++) {        //3,将要执行的代码写在run方法中System.out.println("bb");}}}).start();                                 //4,开启线程
}

public final String getName()：获取线程对象的名称。默认情况下，名字的组成 Thread-编号(编号从0开始)
public final void setName(String name):设置线程名称。

代码演示：

//通过构造方法给name赋值
public static void demo1() {new Thread("芙蓉姐姐") {      //通过构造方法给name赋值public void run() {System.out.println(this.getName() + "....aaaaaaaaa");}}.start();
}
//通过setName()来设置线程的名字
public static void main(String[] args) {Thread t = new Thread() {public void run() {//this.setName("张三");        //在这儿设置也行  在外面设置名称也行System.out.println(this.getName() + "....aaaaaaaaaaaaa");}};t.setName("张三");   //通过setName()来设置线程的名字t.start();
}

public static Thread currentThread():返回当前正在执行的线程对象引用

public static void sleep(long millis):让当前线程休眠millis毫秒

public final void setDaemon(boolean on)：设置线程为守护线程，一旦前台(主线程)结束，守护线程就结束了

public final void join():当前线程暂停，等待指定的线程执行结束后，当前线程再继续

public final void join(long millis)：当前线程暂停, 等待指定的线程执行millis毫秒结束后, 当前线程再继续

public static void yield():暂停当前正在执行的线程对象，并执行其他线程。

public final int getPriority():获取线程优先级

public final void setPriority(int newPriority):更改线程的优先级。线程默认优先级是5。范围是1-10。

注意：优先级可以在一定的程度上，让线程获较多的执行机会。

代码演示：

public static void main(String[] args) {final Thread t1 = new Thread() {public void run() {for(int i = 0; i < 10; i++) {System.out.println(getName() + "...aaaaaaaaaaaaa");}}};Thread t2 = new Thread() {public void run() {for(int i = 0; i < 10; i++) {if(i == 2) {try {t1.join();  //t1插队后，t1执行结束后 t2才能接着执行//t1.join(1);    //插队指定的时间,过了指定时间后,两条线程交替执行} catch (InterruptedException e) {e.printStackTrace();}}System.out.println(getName() + "...bb");}}};t1.start();t2.start();
}

同步代码块

当多线程并发, 有多段代码同时执行时, 我们希望某一段代码执行的过程中CPU不要切换到其他线程工作，这时就需要同步。如果两段代码是同步的，那么同一时间只能执行一段, 在一段代码没执行结束之前, 不会执行另外一段代码。所谓同步代码块就是使用synchronized关键字加上一个锁对象来定义一段代码，这就叫同步代码块，多个同步代码块如果使用相同的锁对象，那么他们就是同步的。

代码演示

public class Demo_Synchronized {public static void main(String[] args) {//匿名内部类使用局部变量，局部变量前面必须加final修饰，为了延长局部变量的声明周期final Printer p = new Printer();  new Thread() {public void run() {while(true) {p.print1();   //调用print1()}}}.start();new Thread() {public void run() {while(true) {p.print2();   //调用print2()}}}.start();}}class Printer {Demo d = new Demo();public void print1() {    synchronized(d) {   //同步代码块,锁机制,锁对象可以是任意的//当多线程并发, 有多段代码同时执行时//我们希望下面代码执行的过程中CPU不要切换到其他线程工作System.out.print("黑");System.out.print("马");System.out.print("程");System.out.print("序");System.out.print("员");System.out.print("\r\n");}}public void print2() {                      synchronized(d) {//如果说两块代码想同步的话，那么这两个同步代码块的锁对象必须是同一个锁对象，所以说上面的锁对象是d，这一个锁对象也是d//我们希望下面代码执行的过程中CPU不要切换到其他线程工作System.out.print("传");System.out.print("智");System.out.print("播");System.out.print("客");System.out.print("\r\n");}}
}class Demo{}

同步方法

使用synchronized关键字修饰一个方法，该方法中所有的代码都是同步的，非静态同步函数的锁是当前对象this，静态的同步函数的锁是当前类的字节码对象。

代码演示：

public class Demo_Synchronized {public static void main(String[] args) {//匿名内部类使用局部变量，局部变量前面必须加final修饰，为了延长局部变量的声明周期final Printer2 p = new Printer2();new Thread() {public void run() {while(true) {p.print1();}}}.start();new Thread() {public void run() {while(true) {p.print2();}}}.start();}
}class Printer2 {Demo d = new Demo();//非静态的同步方法的锁对象是神马?//答:非静态的同步方法的锁对象是this//静态的同步方法的锁对象是什么?//是该类的字节码对象public static synchronized void print1() {//同步方法只需要在方法上加synchronized关键字即可System.out.print("黑");System.out.print("马");System.out.print("程");System.out.print("序");System.out.print("员");System.out.print("\r\n");}public static void print2() {synchronized(Printer2.class) {       System.out.print("传");System.out.print("智");System.out.print("播");System.out.print("客");System.out.print("\r\n");}}
}

死锁
同步代码块的嵌套就容易出现死锁。所以开发中尽量避免同步代码块的嵌套。

代码演示：

public class Demo5_DeadLock {/**@param args*/private static String s1 = "筷子左";private static String s2 = "筷子右";public static void main(String[] args) {new Thread() {public void run() {while(true) {synchronized(s1) {System.out.println(getName() + "...获取" + s1 + "等待" + s2);synchronized(s2) {System.out.println(getName() + "...拿到" + s2 + "开吃");}}}}}.start();new Thread() {public void run() {while(true) {synchronized(s2) {System.out.println(getName() + "...获取" + s2 + "等待" + s1);synchronized(s1) {System.out.println(getName() + "...拿到" + s1 + "开吃");}}}}}.start();}
}

Vector,StringBuffer,Hashtable这些类之所以说是同步的，是因为他们里面的方法上都加了synchronized

Collections.synchroinzedXxx(xxx)：可以返回一个线程安全的集合
public static Collection synchronizedCollection(Collection c)
public static Set synchronizedSet(Set s)
public static List synchronizedList(List list)
public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)

注：Vector是线程安全的,ArrayList是线程不安全的

StringBuffer是线程安全的,StringBuilder是线程不安全的

Hashtable是线程安全的,HashMap是线程不安全的

想了解更多学习知识，请关注微信公众号“阿Q说”，获取更多学习资料吧！你也可以后台留言说出你的疑惑，阿Q将会在后期的文章中为你解答。每天学习一点点，每天进步一点点。