Java多线程Thread+synchronized

Java多线程Thread

Java中的Thread是Runnable接口的子类，但其没有完全实现run()方法，所以说如果继承Thread类实现多线程，仍旧需要覆写run()方法，从中可以看出Thread类用到了Java设计模式的代理模式（对代理目标进行增强）。

一、继承Thread 类

新建一个类继承Thread类，并且重写里面的run()方法，把你想要多线程做的事写在run()方法中

package com.hxh.concurrencypratice.thread;

/**
 * @author huangxh92
 * @description
 * @creat 2019-11-15 15:19:34
 **/
public class ThreadTest extends Thread {
    static int count = 0;

    public  void run() {

        for (int i = 1; i <=10; i++) {
           System.out.println(Thread.currentThread().getName() + "过程的count:" + count);
           count++;
        }
       System.out.println(Thread.currentThread().getName() + "结束线程");
    }
}

二、创建线程对象，执行run方法

（1）将线程对象放入线程

package com.hxh.concurrencypratice.thread;

/**
 * @author huangxh92
 * @description
 * @creat 2019-11-15 15:19:34
 **/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadTest threadTest=new ThreadTest();
        Thread threadTest0 = new Thread(threadTest);
        Thread threadTest1 = new Thread(threadTest);
        threadTest0.start();
        threadTest1.start();
        threadTest0.join();
        threadTest1.join();
        System.out.println(Thread.currentThread().getName()+"中的count:"+ThreadTest.count);
    }
}

（2）新建线程对象启动线程对象的start()方法

package com.hxh.concurrencypratice.thread;

/**
 * @author huangxh92
 * @description
 * @creat 2019-11-15 15:19:34
 **/
  public static void main(String[] args) throws InterruptedException {
       
        ThreadTest threadTest0 = new  ThreadTest();
        ThreadTest threadTest1 = new  ThreadTest();
        threadTest0.start();
        threadTest1.start();
        threadTest0.join();
        threadTest1.join();
        System.out.println(Thread.currentThread().getName()+"中的count:"+ThreadTest.count);
    }
}

（3）通过匿名类方式实现

package com.hxh.concurrencypratice.thread;

/**
 * @author huangxh92
 * @description
 * @creat 2019-11-15 15:19:34
 **/
public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadTest threadTest = new ThreadTest();
        Thread threadTest0 = new Thread() {
            int count = 0;
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "匿名过程的count:" + count);
                    count++;
                }
                System.out.println(Thread.currentThread().getName() + "结束线程");
            }
        };
        Thread threadTest1 = new Thread() {
            int count = 0;
            public void run() {
                for (int i = 1; i <= 10; i++) {
                    System.out.println(Thread.currentThread().getName() + "匿名过程的count:" + count);
                    count++;
                }
                System.out.println(Thread.currentThread().getName() + "结束线程");
            }
        };
        threadTest0.start();
        threadTest1.start();
        threadTest0.join();
        threadTest1.join();
        System.out.println(Thread.currentThread().getName() + "中的count:" + ThreadTest.count);
    }
}

只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是实现Runnable接口

（4）运行结果

可见两个线程并行，其中threadTest0.join(); threadTest1.join();是将当前主线程阻塞到threadTest0、threadTest1完成后才执行，其中的count是静态变量所以引起线程不安全，如何使得线程安全可以在run()方法前加上互斥锁

三、加上互斥锁对比

（1）run()方法加上对象锁

package com.hxh.concurrencypratice.thread;

/**
 * @author huangxh92
 * @description
 * @creat 2019-11-15 15:19:34
 **/
public class ThreadTest extends Thread {
    static int count = 0;

    public synchronized void run() {

        for (int i = 1; i <=10; i++) {
           System.out.println(Thread.currentThread().getName() + "过程的count:" + count);
           count++;
        }
       System.out.println(Thread.currentThread().getName() + "结束线程");
    }
}

（2）运行结果

加入对象锁之后一次只允许一个线程访问这个对象的这个方法达到线程安全，要注意的是如果像2.2那样运行线程，因为两个不同对象，所以线程还是会并行访问这个方法