Java并发编程原理与实战一（线程状态及创建线程的多种方式）

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个数据库开发实战，手把手教大家学习《Java并发编程原理与实战一（线程状态及创建线程的多种方式）》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

一、为什么要学习并发编程

1.发挥多处理的强大能力 
2.建模的简单性 
3.异步事件的简化处理 
4.响应更加灵敏的用户界面

二、并发的缺点

1.安全性问题

多线程环境下 
多个线程共享一个资源 
对资源进行非原子性操作

2.活跃性问题（饥饿）

1、死锁 
2、饥饿 
饥饿与公平 
1）高优先级吞噬所有低优先级的CPU时间片 
2）线程被永久堵塞在一个等待进入同步块的状态 
3）等待的线程永远不被唤醒 
如何尽量避免饥饿问题 

• 设置合理的优先级 
• 使用锁来代替synchronized

3、活锁

3.性能问题

三、线程的状态

线程在一定条件下，状态会发生变化。线程一共有以下几种状态：

1、新建状态(New)：新创建了一个线程对象。

2、就绪状态(Runnable)：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于“可运行线程池”中，变得可运行，只等待获取CPU的使用权。即在就绪状态的进程除CPU之外，其它的运行所需资源都已全部获得。

3、运行状态(Running)：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态(Blocked)：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。

阻塞的情况分三种：

(1)、等待阻塞：运行的线程执行wait()方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify()或notifyAll()方法才能被唤醒，

(2)、同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入“锁池”中。

(3)、其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

5、死亡状态(Dead)：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。 
线程变化的状态转换图如下： 

四、创建线程的多种方式

1、继承Thread类

public class Demo1 extends Thread {

    public Demo1(String name) {
        super(name);
    }

    @Override
    public void run() {
        while(!interrupted()) {
            System.out.println(getName() + "线程执行了 .. ");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {

        Demo1 d1 = new Demo1("first-thread");
        Demo1 d2 = new Demo1("second-thread");


        d1.start();
        d2.start();

//      d1.stop();
        d1.interrupt();
    }

}

2、实现Runnable接口

public class Demo2 implements Runnable {

    @Override
    public void run() {
        while(true) {
            System.out.println("thread running ...");
        }
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new Demo2());
        thread.start();
    }

}

3、匿名内部类的方式

public class Demo3 {

    public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("runnable");
            }
        }) {
            public void run() {
                System.out.println("sub");
            };
        }.start();


    }

}

4、带返回值的线程

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Demo4 implements Callable {


    public static void main(String[] args) throws Exception {
        Demo4 d = new Demo4();

        FutureTask task = new FutureTask(d);

        Thread t = new Thread(task);

        t.start();

        System.out.println("我先干点别的。。。");

        Integer result = task.get();
        System.out.println("线程执行的结果为：" + result);
    }

    @Override
    public Integer call() throws Exception {
        System.out.println("正在进行紧张的计算....");
        Thread.sleep(3000);
        return 1;
    }

}

5、定时器（quartz）

import java.util.Timer;
import java.util.TimerTask;

public class Demo5 {

    public static void main(String[] args) {

        Timer timer = new Timer();

        timer.schedule(new TimerTask() {

            @Override
            public void run() {
                // 实现定时任务
                System.out.println("timertask is run");
            }
        }, 0, 1000);

    }

}

6、线程池的实现

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 线程池
 * @author Administrator
 *
 */
public class Demo6 {

    public static void main(String[] args) {

        ExecutorService threadPool = Executors.newCachedThreadPool();

        for (int i = 0; i 

7、Lambda表达式实现

import java.util.Arrays;
import java.util.List;
/**
 * lambda并行计算
 * @author Administrator
 *
 */
public class Demo7 {

    public static void main(String[] args) {

        List values = Arrays.asList(10,20,30,40);
        int res = new Demo7().add(values);
        System.out.println("计算的结果为：" + res);


    }



    public int add (List values) {
        values.parallelStream().forEach(System.out :: println);
        return values.parallelStream().mapToInt( i -> i * 2).sum();
    }

}

8、Spring实现多线程

五、Synchronized原理与使用

1、内置锁 
2、互斥锁

1、修饰普通方法 
2、修饰静态方法 
3、修饰代码块

public class Sequence {

    private int value;

    /**
     * synchronized 放在普通方法上，内置锁就是当前类的实例
     * @return
     */
    public synchronized int getNext() {
        return value ++;
    }

    /**
     * 修饰静态方法，内置锁是当前的Class字节码对象
     * Sequence.class
     * @return
     */
    public static synchronized int getPrevious() {
//      return value --;
        return 0;
    }

    public int xx () {

        // monitorenter
        synchronized (Sequence.class) {

            if(value > 0) {
                return value;
            } else {
                return -1;
            }

        }
        // monitorexit

    }

    public static void main(String[] args) {

        Sequence s = new Sequence();
//      while(true) {
//          System.out.println(s.getNext());
//      }

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }

}

六、任何对象都可以作为锁，那么锁信息又存在对象的什么地方呢？

存在对象头中

对象头中的信息 
Mark Word：线程id、Epoch、对象的分代年龄信息、是否是偏向锁、锁标志位 
Class Metadata Address 
Array Length

偏向锁

每次获取锁和释放锁会浪费资源 
很多情况下，竞争锁不是由多个线程，而是由一个线程在使用。 
只有一个线程在访问同步代码块的场景

重量级锁

七、设置线程优先级

public class Target implements Runnable {

    @Override
    public void run() {

        while(true) {
            System.out.println(Thread.currentThread().getName() + " ...");
//          Thread.sleep(1);
        }

    }

}

public class Demo {

    public static void main(String[] args) {


        Thread t1 =  new Thread(new Target());
        Thread t2 =  new Thread(new Target());


        t1.setPriority(1);
        t2.setPriority(Thread.MIN_PRIORITY);

        t1.start();
        t2.start();

    }

}

八、单例模式与线程安全性问题

饿汉式

没有线程安全性问题

public class Singleton {

    // 私有化构造方法
    private Singleton () {}

    private static Singleton instance = new Singleton();

    public static Singleton getInstance() {
        return instance;
    }

}

懒汉式
双重检查加锁解决线程安全性问题

public class Singleton2 {

    private Singleton2() {}
    //volatile 解决指令重排序导致的线程安全性问题、过多将导致cpu缓存优化失效
    private static volatile Singleton2 instance;

    /**
     * 双重检查加锁
     * 
     * @return
     */
    public static Singleton2 getInstance () {
        // 自旋   while(true)
        if(instance == null) {
            synchronized (Singleton2.class) {
                if(instance == null) {
                    instance = new Singleton2();  // 指令重排序

                    // 申请一块内存空间   // 1
                    // 在这块空间里实例化对象  // 2
                    // instance的引用指向这块空间地址   // 3
                }
            }
        }
        return instance;
    }

}

九、锁重入

public class Demo {


    public synchronized void a () {
        System.out.println("a");
//      b();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void b() {
        System.out.println("b");

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        //同一个对对象将会阻塞
        Demo d1= new Demo();
        Demo d2= new Demo();

        new Thread(new Runnable() {

            @Override
            public void run() {
                d1.a();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                d2.b();
            }
        }).start();
    }

}

十、自旋锁

import java.util.Random;

/**
 * 多个线程执行完毕之后，打印一句话，结束
 * @author worker
 *
 */
public class Demo2 {

    public static void main(String[] args) {

        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程执行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程执行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程执行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程执行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 线程执行...");

                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println(Thread.currentThread().getName() + " 线程执行完毕了...");
            }
        }).start();

        while(Thread.activeCount() != 1) {
            // 自旋
        }
        System.out.println("所有的线程执行完毕了...");
    }

}

十一、死锁

public class Demo3 {

    private Object obj1 = new Object();
    private Object obj2 = new Object();


    public void a () {
        synchronized (obj1) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj2) {
                System.out.println("a");
            }
        }
    }

    public void b () {
        synchronized (obj2) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj1) {
                System.out.println("b");
            }
        }
    }

    public static void main(String[] args) {

        Demo3 d = new Demo3();

        new Thread(new Runnable() {

            @Override
            public void run() {
                d.a();
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                d.b();
            }
        }).start();
    }

}

十二、轻量级锁

Volatile

Volatile称之为轻量级锁，被volatile修饰的变量，在线程之间是可见的。 
可见：一个线程修改了这个变量的值，在另外一个线程中能够读到这个修改后的值。 
Synchronized除了线程之间互斥意外，还有一个非常大的作用，就是保证可见性

public class Demo2 {

    public volatile boolean run = false;

    public static void main(String[] args) {

        Demo2 d = new Demo2();

        new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 1;i

Lock指令

在多处理器的系统上 
1、将当前处理器缓存行的内容写回到系统内存 
2、这个写回到内存的操作会使在其他CPU里缓存了该内存地址的数据失效 
硬盘 – 内存 – CPU的缓存 
多个线程可以同时

十三、JDK提供的原子类原理及使用

1、原子更新基本类型、原子更新数组、原子更新抽象类型、原子更新字段

public class User {

    private String name;

    public volatile int old;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getOld() {
        return old;
    }

    public void setOld(int old) {
        this.old = old;
    }

}

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReference;

public class Sequence {

    private AtomicInteger value  = new AtomicInteger(0);

    private int [] s = {2,1,4,6};

    AtomicIntegerArray a = new AtomicIntegerArray(s);


    AtomicReference user = new AtomicReference();

    AtomicIntegerFieldUpdater old =  AtomicIntegerFieldUpdater.newUpdater(User.class, "old");

    /**
     * @return
     */
    public  int getNext() {

        User user = new User();
        System.out.println(old.getAndIncrement(user));
        System.out.println(old.getAndIncrement(user));
        System.out.println(old.getAndIncrement(user));



        a.getAndIncrement(2);
        a.getAndAdd(2, 10);
        return value.getAndIncrement();
    }

    public static void main(String[] args) {

        Sequence s = new Sequence();

        new Thread(new Runnable() {

            @Override
            public void run() {
//              while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
//              }
            }
        }).start();

    }

}

十四、Lock接口的认识与使用

Lock与Synchronized的区别：

Lock需要显示地获取和释放锁，繁琐能让代码更灵活 
Synchronized不需要显示地获取和释放锁，简单

Lock的优势：

使用Lock可以方便的实现公平性

非阻塞的获取锁 
能被中断的获取锁 
超时获取锁

自己实现一个Lock

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Sequence {

    private int value;
    Lock lock = new ReentrantLock();
    Lock l1 = new ReentrantLock();

    /**
     * @return
     */
    public  int getNext() {
        lock.lock();
        int a = value ++;
        lock.unlock();
        return a;
    }

    public static void main(String[] args) {

        Sequence s = new Sequence();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                while(true) {
                    System.out.println(Thread.currentThread().getName() + " " + s.getNext());
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

    }

}

今天关于《Java并发编程原理与实战一（线程状态及创建线程的多种方式）》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于mysql的内容请关注golang学习网公众号！