并发编程之多线程基础
一。多线程创建方式
1。第一种继承Thread类 重写run方法
class CreateThread extends Thread { // run方法中，需要线程需要执行代码 @Override public void run() { System.out.println("运行子线程"); } } public class ThreadDemo01 { public static void main(String[] args) { System.out.println("main... 主线程开始..."); // 1.创建线程 CreateThread CreateThread = new CreateThread(); // 2.启动线程 CreateThread.start(); System.out.println("main... 主线程结束..."); } }
2。 第二种实现Runnable接口,重写run方法
class CreateRunnable implements Runnable { @Override public void run() { System.out.println("运行子线程"); } } public class ThreadDemo2 { public static void main(String[] args) { System.out.println("-----多线程创建开始-----"); // 1.创建一个线程 CreateRunnable createThread = new CreateRunnable(); // 2.开始执行线程 注意 开启线程不是调用run方法，而是start方法 System.out.println("-----多线程创建启动-----"); Thread thread = new Thread(createThread); thread.start(); System.out.println("-----多线程创建结束-----"); } }
3。使用匿名内部类方式
public class ThreadDemo3 { public static void main(String[] args) { System.out.println("-----多线程创建开始-----"); Thread thread = new Thread(new Runnable() { public void run() { System.out.println("运行子线程"); } }); thread.start(); System.out.println("-----多线程创建结束-----"); } }
注意：
1> 一般使用Runnable接口，符合面向接口编程，而且实现了接口还可以继续继承，继承了类不能再继承。
2> 开启线程不是调用run方法，而是start方法。
二。守护线程
Java中有两种线程，一种是用户线程，另一种是守护线程。
用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止。
守护线程当进程不存在或主线程停止，守护线程也会被停止。
使用setDaemon(true)方法设置为守护线程。如果不设置为守护线程，子线程还好运行。
public class DaemonThread { public static void main(String[] args) { Thread thread = new Thread(new Runnable() { @Override public void run() { while (true) { try { Thread.sleep(1000); } catch (Exception e) { // TODO: handle exception } System.out.println("我是子线程..."); } } }); thread.setDaemon(true); thread.start(); for (int i = 0; i < 5; i++) { try { Thread.sleep(1000); } catch (Exception e) { } System.out.println("我是主线程"); } System.out.println("主线程执行完毕!"); } }
三。多线程运行状态
线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
1。新建状态
当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，程序还没有开始运行线程中的代码。
2。就绪状态
当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。
3。运行状态
当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。
4。阻塞状态
线程运行过程中，可能由于各种原因进入阻塞状态:
1> 线程通过调用sleep方法进入睡眠状态；
2> 线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3> 线程试图得到一个锁，而该锁正被其他线程持有；
4> 线程在等待某个触发条件；
5。死亡状态
有两个原因会导致线程死亡：
1> run方法正常退出而自然死亡，
2> 一个未捕获的异常终止了run方法而使线程猝死。
为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true；
如果线程仍旧是new状态且不是可运行的， 或者线程死亡了，则返回false。
四。join()方法作用
当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1，执行完子线程后才执行主线程。
public class Main { public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(new Runnable() { @Override public void run() { System.out.println("先执行子线程"); } }); t1.start(); // 当在主线程当中执行到t1.join()方法时，就认为主线程应该把执行权让给t1 t1.join(); System.out.println("接着执行主线程"); } }
2。优先级
在JAVA线程中，通过一个int priority来控制优先级，范围为1-10，其中10最高，默认值为5。优先级越高，被分配执行的概率就越大。
class PrioritytThread implements Runnable { public void run() { for (int i = 0; i < 10; i++) { System.out.println(Thread.currentThread().toString() + "---i:" + i); } } } public class ThreadDemo4 { public static void main(String[] args) { PrioritytThread prioritytThread = new PrioritytThread(); Thread t1 = new Thread(prioritytThread); Thread t2 = new Thread(prioritytThread); t1.start(); // 注意设置了优先级， 不代表每次都一定会被执行。 只是被CPU调度概率高。 t1.setPriority(10); t2.start(); } }
3。Yield方法
yield()让当前正在运行的线程回到可运行状态，以允许具有相同优先级的其他线程获得运行的机会。但可能会没有效果，因为该线程可能会再次被选中运行。
五。内置的锁
Java提供了一种内置的锁机制来支持原子性，每一个Java对象都可以用作一个实现同步的锁，称为内置锁。
线程进入同步代码块之前自动获取到锁，代码块执行完成正常退出或代码块中抛出异常退出时会释放掉锁。
内置锁为互斥锁，即线程A获取到锁后，线程B阻塞直到线程A释放锁，线程B才能获取到同一个锁。
内置锁使用synchronized关键字实现，synchronized关键字有两种用法：
*** 修饰需要进行同步的方法（所有访问状态变量的方法都必须进行同步），此时充当锁的对象为调用同步方法的对象。
*** 同步代码块和直接使用synchronized修饰需要同步的方法是一样的，但是锁的粒度可以更细，并且充当锁的对象不一定是this，也可以是其它对象，所以使用起来更加灵活。
class SynObj{ // 同步方法，锁对象为this public synchronized void showA(){ System.out.println("showA.."); try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } } public void showB(){ // 同步代码块，锁对象为this synchronized (this) { System.out.println("showB.."); } } public void showC(){ String s="1"; // 同步代码块，锁对象为s synchronized (s) { System.out.println("showC.."); } } // 静态同步函数,锁是该函数所属字节码文件对象，可以使用this.getClass()方法获取，也可以用当前 类名.class表示。 public static synchronized void showD(){ System.out.println("showD.."); } } public class TestSyn { public static void main(String[] args) { final SynObj sy=new SynObj(); new Thread(new Runnable() { @Override public void run() { sy.showA(); } }).start(); new Thread(new Runnable() { @Override public void run() { sy.showB(); } }).start(); new Thread(new Runnable() { @Override public void run() { sy.showC(); } }).start(); new Thread(new Runnable() { @Override public void run() { SynObj.showD(); } }).start(); } }
shouA和showC以及showD会立刻打印出来，showC三秒后才打印处理，因为showA和showB的锁对象都是this。
2。多线程死锁
多个并发进程因争夺系统资源而产生相互等待的现象。
死锁产生的4个必要条件：
1> 互斥：某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结束。
2> 占有且等待：一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。
3> 不可抢占：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。
4> 循环等待：存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。
避免死锁：银行家算法等
六。ThreadLocal
ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
ThreadLocal类接口很简单，只有4个方法：
1。void set(Object value)设置当前线程的线程局部变量的值。
2。public Object get()该方法返回当前线程所对应的线程局部变量。
3。public void remove()将当前线程局部变量的值删除，目的是为了减少内存的占用。
当线程结束后，对应该线程的局部变量将自动被垃圾回收，所以显式调用该方法清除线程的局部变量并不是必须的操作，但它可以加快内存回收的速度。
4。protected Object initialValue()返回该线程局部变量的初始值。
这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。
class Res { public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() { protected Integer initialValue() { return 0; }; }; public Integer getNumber() { int count = threadLocal.get() + 1; threadLocal.set(count); return count; } } public class ThreadLocaDemo2 extends Thread{ private Res res; public ThreadLocaDemo2(Res res) { this.res = res; } @Override public void run() { for (int i = 0; i < 3; i++) { System.out.println(Thread.currentThread().getName() + "," + res.getNumber()); } } public static void main(String[] args) { Res res = new Res(); ThreadLocaDemo2 t1 = new ThreadLocaDemo2(res); ThreadLocaDemo2 t2 = new ThreadLocaDemo2(res); t1.start(); t2.start(); } }
ThreadLoca实现原理：
每个Thread的对象都有一个ThreadLocalMap，当创建一个ThreadLocal的时候，就会将该ThreadLocal对象添加到该Map中，其中键就是ThreadLocal，值可以是任意类型。
七。多线程三大特性
1。原子性：一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
2。可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
3。有序性：程序执行的顺序按照代码的先后顺序执行。
一般来说处理器为了提高程序运行效率，可能会对输入代码进行优化。
它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。
