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

拼搏现实的明天。 2022-05-28 02:52 143阅读 0赞

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

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()方法，该线程结束生命周期。  
**线程变化的状态转换图如下：**  
![这里写图片描述][70]

# 四、创建线程的多种方式 #

## 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<Integer> { 
    
    
        public static void main(String[] args) throws Exception {
            Demo4 d = new Demo4();
    
            FutureTask<Integer> 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 < 1000; i++) {
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName());
                    }
                });
            }
    
            threadPool.shutdown();
        }
    
    }

## 7、Lambda表达式实现 ##

import java.util.Arrays;
    import java.util.List;
    /** * lambda并行计算 * @author Administrator * */
    public class Demo7 { 
    
        public static void main(String[] args) {
    
            List<Integer> values = Arrays.asList(10,20,30,40);
            int res = new Demo7().add(values);
            System.out.println("计算的结果为：" + res);
    
    
        }
    
    
    
        public int add (List<Integer> 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<=10;i++) {
                        System.err.println("执行了第 " + i + " 次");
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    d.run = true;
                }
            }).start();
    
            new Thread(new Runnable() {
    
                @Override
                public void run() {
                    while(!d.run) {
                        // 不执行
                    }
                    System.err.println("线程2执行了...");
                }
            }).start();
    
    
        }
    
    }

## 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> user = new AtomicReference<>();
    
        AtomicIntegerFieldUpdater<User> 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();
    
        }
    
    }

[70]: /images/20220528/f8f81037df0f4c2bac49763489e94e7b.png