并发编程入门（一）

并发编程的学习目的

初步了解并发

1. 面试非常重要

这一点能够充分的体现出你个人的一个知识面，以及你的学习深度

2. 对自己的技术有很大的提升

因为你懂了并发编程，就会有很大的能力提升我们的技术

3. 学习了并发编程，对分布式系统中的并发，分布式，并行处理的问题，就可以有自己的解决方案了

在我们的日常生活中，并发是无处不在的，我们可以从生活的角度，去进行理解，然后更好的利用并发知识来解决我们生活中的难题

4. 我们改如何学习并发编程？

在公司里面有很多Java程序员，又或者有很多的技术Leader，他们可能知道多线程中有synchronized，volatile，ReentranLock，Concurrent下数据包等等，这些看似高深的代名词，可能他们知道如何去使用，但是我们要讲究如何使用达到最好

线程安全

1.线程安全的概念

当多个线程访问某一个类（对象或者方法）时，这个类始终都能表现出正确的行为，那么这个类（对象或者方法）就是线程安全的

2.Synchronize的理解

可以在任意对象，或者方法上加锁，而加锁的这段代码被称为“互斥区域”，或者“临界区”

/**
 * @program: mutilStudy
 * @description: 学习多线程
 * @author:葫芦爷爷
 * @create: 2019-04-08 11:52
 **/
public class MyThread extends Thread{
    private int count = 5;
    //Synchronized加锁
    @Override
    public void run (){
        count--;
        System.out.println(MyThread.currentThread().getName()+" count ="+count);

    }
  /**
   * @Description
   * @author 葫芦爷爷
   * @param [args]
   * @return void
   * @date 2019-4-8 12:44
   */
    public static void main(String[] args) {
        /**
         * 分析：执行多个线程的时候这个里面的线程是怎么进行运行的
         * 和synchronize如何使用，用完之后是怎么样的一个效果呢？
         * 根据之前的理解我们可以知道可以对方法进行上锁
         *  1.拿到锁就执行这段代码
         *  2.没有拿到就不停的去试图拿到锁，知道获取到锁，访问到共享的资源
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"T1");
        Thread t2 = new Thread(myThread,"T2");
        Thread t3 = new Thread(myThread,"T3");
        Thread t4 = new Thread(myThread,"T4");
        Thread t5 = new Thread(myThread,"T5");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();


    }
}

结果展示

T1 count =3
T2 count =3
T3 count =2
T4 count =1
T5 count =0

我们可以清楚的看到并没有按照想想中的 4 3 2 1 0 打印出来，t1 t2 就更好的说明了 他们同时获取到了3个这个共享变量

public class MyThread extends Thread{
    private int count = 5;
    //Synchronized加锁
    @Override
    public synchronized void run (){
        count--;
        System.out.println(MyThread.currentThread().getName()+" count ="+count);

    }
  /**
   * @Description
   * @author jsonlk
   * @param [args]
   * @return void
   * @date 2019-4-8 12:44
   */
    public static void main(String[] args) {
        /**
         * 分析：执行多个线程的时候这个里面的线程是怎么进行运行的
         * 和synchronize如何使用，用完之后是怎么样的一个效果呢？
         * 根据之前的理解我们可以知道可以对方法进行上锁
         *  1.拿到锁就执行这段代码
         *  2.没有拿到就不停的去试图拿到锁，知道获取到锁，访问到共享的资源
         */
        MyThread myThread = new MyThread();
        Thread t1 = new Thread(myThread,"T1");
        Thread t2 = new Thread(myThread,"T2");
        Thread t3 = new Thread(myThread,"T3");
        Thread t4 = new Thread(myThread,"T4");
        Thread t5 = new Thread(myThread,"T5");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();


    }
}

方法上加上synchronize 修饰符
结果

T1 count =4
T2 count =3
T3 count =2
T4 count =1
T5 count =0

多运行一次

T2 count =4
T1 count =3
T3 count =2
T4 count =1
T5 count =0

可以看到结果都是顺序的，但是线程不一样，这是因为cpu调度 跟抢占有关， t2 比t1先拿到资源 那么肯定就先执行