Java并发：并发基础（一）

﹏ヽ暗。殇╰゛Y 2022-02-01 08:55 285阅读 0赞

## 一：线程与进程 ##

**进程**：一个系统至少拥有一个进程，是系统调度和分配志愿的基本单位。  
**线程**：每个线程只有拥有一个线程，线程依附进行进程存在，是真正操作数据的单元。

**JVM内存**：虚拟机内存结构分为堆，栈，方法区，程序计数器。  
**堆**：所有线程共享，存储对象的数据。  
**方法区**：所有线程共享，存储静态变量，常量，JVM加载的类等。  
**栈**：线程私有，存储局部变量及栈帧。  
**程序计数器**：线程私有，用于记录线程的运行进程。

**线程运行时间分配策略**：CPU采用时间片轮询策略，就是给每个线程一定的时间来进行运行它的方法，运行完之后，让出CPU，进入待命状态，程序计数器就是用来干这活的，记录让出CPU时候的执行地址。

## 二：线程创建方式 ##

1.  继承Thead

public class TreadTest { 
            public static void main(String[] args) { 
                    new MyThread().start();
            }
    
    }
    class MyThread extends Thread { 
        @Override
        public void run() { 
            System.out.println("通过继承Tread类创建的线程");
        }
    }

1.  实现Runnable

public class TreadTest { 
            public static void main(String[] args) { 
                new Thread(new Runnable() { 
                    @Override
                    public void run() { 
                        System.out.println("实现Runnable接口创建的线程");
                    }
                }).start();
            }
    }

1.  使用FutureTask

public class TreadTest { 
        public static void main(String[] args) { 
            FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() { 
                @Override
                public String call() throws Exception { 
                    System.out.println("FutureTask创建的线程");
                    return "Hello";
                }
            });
            new Thread(futureTask).start();
        }
    }

**线程创建方式优劣**：  
①.Thread继承，占用继承名额，不容易扩展，便于传递参数，变量。  
②.Runnable接口，不占用继承名额，可以进行自行扩展，但只能使用主线程final类型变量。  
③.FutureTask实现，具有返回值

#### 三：线程通知与等待 ####

1.  wait()  
    变量调用wait()方法，正在使用该变量的线程会被挂起。  
    **前提**：需要获得该变量的监视器锁，关键字synchronized，线程一旦通过wait()进入挂起状态，会释放所拥有的监视器锁。  
    **唤醒方式**：①该变量调用notify()或者notifyAll()。②其它线程调用该线程的interrupt()，该线程报错退出。

public class WaitTest { 
        public static final Integer i = 10;
    
        public static void main(String[] args) throws Exception { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println(Thread.currentThread().getName() + "准备挂起");
                    synchronized (i) { 
                        try { 
                            i.wait();
                        } catch (Exception e) { 
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName() + "唤醒成功");
                }
            }).start();
            try { 
                Thread.sleep(1000l);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (i) { 
                        i.notify();
                    }
                }
            }).start();
        }
    }

wait(long timeout)：比wait()方法多一个超时参数，若在timeout毫秒时间内没有被其他线程唤醒，则会自我复苏，wait()本质上就是wait(0L)。  
wait(long timeout，int nanos)：在nanos>1的时候使timeout递增1，不懂。  
2. notify()  
调用共享变量的notify()，会随机唤醒一个挂起线程。  
3. nitifyAll()  
调用共享变量的notifyAll()，会唤醒全部因该共享变量挂起的变量。

#### 四：线程常用方法 ####

1.  join()  
    由子线程调用，父线程会给阻塞，知道子线程运行完毕后，继续运行。

public final synchronized void join(long millis)
        throws InterruptedException { 
            long base = System.currentTimeMillis();
            long now = 0;
            if (millis < 0) { 
                throw new IllegalArgumentException("timeout value is negative");
            }
            if (millis == 0) { 
            	//检测线程是否运行完毕，没有则继续使该线程的父线程继续挂起。
                while (isAlive()) { 
                    wait(0);
                }
            } else { 
                while (isAlive()) { 
               		//时间做减法，到时间唤醒
                    long delay = millis - now;
                    if (delay <= 0) { 
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

**示例：**

public class JoinTest { 
        public static void main(String[] args) { 
            System.out.println(Thread.currentThread().getName() + "即将挂起");
            Thread thread1 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    for (int i = 0; i < 10; i++) { 
                        if (i == 5) { 
                            try { 
                                Thread.sleep(2000l);
                            }catch (Exception e){ 
    
                            }
                        }
                        System.out.println(i);
                    }
                }
            });
            thread1.start();
            try { 
                thread1.join(1000l);
            } catch (Exception e) { 
            }
            System.out.println(Thread.currentThread().getName() + "恢复运行");
    
        }
    }

1.  sleep()  
    Thread类中的一个静态方法，调用的线程会进入挂起状态，但持有的监视器锁不会让出。

public class SleepTest { 
        public static final Integer i = 100;
        public static void main(String[] args) { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (i){ 
                        System.out.println(Thread.currentThread().getName()+"获得监视器锁，即将挂起");
                        try { 
                            Thread.sleep(3000l);
                        }catch (Exception e){ 
    
                        }
                        System.out.println(Thread.currentThread().getName()+"已经唤醒");
                    }
                }
            }).start();
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println(Thread.currentThread().getName()+"正在等待锁");
                    synchronized (i){ 
                        System.out.println(Thread.currentThread().getName()+"获得监视器锁");
                    }
                }
            }).start();
        }
    }

1.  yield()  
    Thread类的静态方法，当线程调用该方法，会让出CPU的剩余使用时间，等待进入下一轮调度。

public class YieldTest { 
        public static void main(String[] args) { 
            new MyThreadOne().start();
            new MyThreadOne().start();
        }
    }
    
    class MyThreadOne extends Thread { 
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                if (i == 5) { 
                    System.out.println(Thread.currentThread().getName()+"正在让出剩余时间");
                    Thread.yield();
                }
            }
            System.out.println(Thread.currentThread().getName()+"结束");
        }
    }

## 五：线程中断 ##

1.  interrupt()  
    线程调用，当调用该方法，调用的线程被设置中断状态为true，但并未停止运行。如线程当时真处于wait(),sleep(),join()方法而挂起，会进行报错。
2.  isInterrupted()  
    检查当前线程中断标志是否为true
3.  interrupted()  
    检查主线程的中断标志是否为true

## 六：死锁 ##

**最简单的死锁场景**：

public class LockTest { 
        public static Integer A = 100;
        public static Integer B = 10;
    
        public static void main(String[] args) { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (A) { 
                        System.out.println(Thread.currentThread().getName() + "获得LockA");
                        try { 
                            Thread.sleep(5000l);
                        } catch (Exception e) { 
                            e.printStackTrace();
                        }
                        synchronized (B) { 
                            System.out.println(Thread.currentThread().getName() + "获得LockB");
                        }
                    }
                }
            }).start();
    
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    synchronized (B) { 
                        System.out.println(Thread.currentThread().getName() + "获得LockB");
                        try { 
                            Thread.sleep(5000l);
                        } catch (Exception e) { 
                            e.printStackTrace();
                        }
                        synchronized (A) { 
                            System.out.println(Thread.currentThread().getName() + "获得LockA");
                        }
                    }
                }
            }).start();
        }
    }

**造成死锁条件：**  
①：互斥条件：资源同时只用由一个线程占有，其他线程想要调用，只能等待。  
②：请求并持有条件：该线程在持有至少一个资源的情况下，再次请求新资源，而新资源已被占用，会造成原有线程的阻塞。  
③：不可剥夺条件：线程获取的资源在自己使用完之前不会对资源进行释放。  
④：环路等待条件：发生死锁时，必定存在一个线程-资源的回环。  
**如何避免死锁：** 保证线程获取资源的有效性即可。

## 七：守护线程与用户线程 ##

**守护线程：** 守护线程的存在不会影响JVM的退出，垃圾回收器的线程Reference Handler就是一个守护线程。  
下列即可设置一个守护线程：

Thread thread = new Thread();
          thread.setDaemon(true);

**用户线程：** 我们之前的定义的线程都为用户线程， 一旦用户线程全部结束了，JVM就会退出。

## 八：ThreadLocal ##

多线程都同一个共享变量进行操作时，需要进行加锁操作，会增加使用者的负担及考察使用者对于锁的了解。ThreadLocal为线程独有的变量，每个线程的ThredaLocal的值都不一样。  
**使用方法：**  
**ThreadLocal常用方法：** get()，set()，remove()

public class ThreadLocalTest { 
        public static ThreadLocal<String> local = new ThreadLocal<>();
    
        public static void main(String[] args) { 
            Thread t1 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    local.set("线程一的变量");
                    System.out.println(Thread.currentThread().getName()+local.get());
                    local.remove();
                    System.out.println(Thread.currentThread().getName()+local.get());
                }
            });
            Thread t2 = new Thread(new Runnable() { 
                @Override
                public void run() { 
                    System.out.println(Thread.currentThread().getName()+local.get());
                    local.set("线程二的变量");
                    System.out.println(Thread.currentThread().getName()+local.get());
                    local.remove();
                    System.out.println(Thread.currentThread().getName()+local.get());
                }
            });
            t1.start();
            try { 
    
                Thread.sleep(100l);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            t2.start();
    
        }
    }

**ThreadLocal原理：**

public class Thread implements Runnable { 
    	//...
    	ThreadLocal.ThreadLocalMap threadLocals = null;
     	ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;
     	//...
     	}

Thread类中有如上两个变量，默认为null，那我们可猜想，ThreadLocal只是一个工具类，实际操作的数据为Thread类中这两个变量。有效期等同于线程的生命周期。  
ThreadLocalMap是一个定制化的HashMap。  
**ThreadLocal的set()方法：**

public void set(T value) { 
        	//获取执行的线程
            Thread t = Thread.currentThread();
            //获取线程的threadLocals 变量
            ThreadLocalMap map = getMap(t);
            if (map != null)
            	//添加值
                map.set(this, value);
            else
            	//初始化HashMap，并赋值于线程的threadLocals变量
                createMap(t, value);
        }
        
        void createMap(Thread t, T firstValue) { 
            t.threadLocals = new ThreadLocalMap(this, firstValue);
        }

ThreadLocal的get()方法：

public T get() { 
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null) { 
            	//取出映射
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) { 
                    @SuppressWarnings("unchecked")
                    //取出Value并返回
                    T result = (T)e.value;
                    return result;
                }
            }
            //将Thread类的threadLocals变量的Value设置为null并初始化
            return setInitialValue();
        }
    
    	private T setInitialValue() { 
            T value = initialValue();
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
            return value;
        }

ThreadLocal的remove()方法：

public void remove() { 
             ThreadLocalMap m = getMap(Thread.currentThread());
             if (m != null)
                 m.remove(this);
         }

**可继承的ThreadLocal：** InheritableThreadLocal类，继承ThreadLocal类，重写三个方法，可以让子线程访问父线程设置在该线程的本地变量。

public class InheritableThreadLocal<T> extends ThreadLocal<T> { 
    	//
        protected T childValue(T parentValue) { 
            return parentValue;
        }
    	//改变get()方法的获取变量
        ThreadLocalMap getMap(Thread t) { 
           return t.inheritableThreadLocals;
        }
        //初始化map的时候的赋值变量为inheritableThreadLocals 
        void createMap(Thread t, T firstValue) { 
            t.inheritableThreadLocals = new ThreadLocalMap(this, firstValue);
        }
    }

**线程初始化：** 会对象父线程的inheritThreadLocals 变量进行判读，如果有则会赋值到子线程的变量上。

private void init(ThreadGroup g, Runnable target, String name,
                          long stackSize, AccessControlContext acc,
                          boolean inheritThreadLocals) { 
            //...
            //获取初始这个线程的线程，也就是父线程
            Thread parent = currentThread();
            //... inheritThreadLocals 默认为true
            if (inheritThreadLocals && parent.inheritableThreadLocals != null)
            	//初始化inheritableThreadLocals变量
                this.inheritableThreadLocals =
                    ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
             //...
        }
        
        static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) { 
            return new ThreadLocalMap(parentMap);
        }