1. 多线程
进程：正在运行的程序，是系统进行资源和调度的独立单位，每一进程都有独立的内存空间和系统资源
多进程的意义：单进程的计算机只能做一件事情，多进程可以执行多个进程 ，提供CPU的使用率，实际是CPU在不同进程之间的高效切换
线程：在同一个进程内可以执行多个任务，而每一个任务都可以看成是一个线程，是程序的执行单元，执行路径，是程序使用CPU的最基本单位，多线程有多条执行路径
多线程的意义：提供程序的使用率，程序的执行都是在抢CPU的执行权，线程的执行具有随机性
Java程序的运行原理：由java命令启动JVM，JVM启动相当于启动了一个进程
JVM虚拟机的启动时单线程的，垃圾回收线程也要启动，最少需要启动两个 线程
2. 多线程实现
2.1 继承Thread类，该子类重写run()方法，创建对象，启动线程
run()和start()的区别：
run()：仅仅是封装被线程执行的代码，调用时普通方法。
start()：首先启动了线程，然后再由JVM去调用线程的run()方法
public static void main(String[] args){ MyThread my1 = new MyThread(); MyThread my2 = new MyThread();
my1.setName("xiaojignzi");
my2.setName("xiaojunzi");
my1.start(); //my1.start(); IllegalThreadStateException:非法的线程状态异常，相当于一个线程被调用了两次 my2.start(); }
获取线程对象的名称
public class MyThread extends Thread { @Override public void run(){ for(int x = 0; x < 100; x++){ System.out.println(getName() + "-----" + x); } } }
如何获取main方法所在的线程对象的名称
Thread.currentThread().getName()
线程的调度
计算机只有一个CPU时，CPU在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。
线程具有两种调度模型
1. 分时调度模型：所有的线程轮流调用CPU的使用权，平均分配给每个线程占用CPU的时间片
2. 抢占式调度模型，优先让优先级高的线程使用CPU，如果线程的优先级相同会随机选择一个，优先级高的线程获取CPU时间片相对多一些
java使用抢占式调度模型:
int getPriority()：获取线程的优先级
setPriority(int)：设置线程的优先级
默认的优先级为5，可以设置的优先级范围是1-10
线程的控制：
线程休眠：public static void sleep(long millis)：在指定的毫秒内让当前正在执行的线程休眠（暂停实现）。此操作受到系统计时器和调度程序的精确度和准确性的影响
线程加入：public final void join()：等待本线程终止，程序再继续向后面执行
线程礼让：public static void yield()：暂停当前正在执行的线程对象，并执行其他线程，不能靠它保证每个线程轮流依次指向
线程守护：public final void setDaemon(boolean on)：将该线程标记为守护线程或者用户线程，当正在运行的线程都是守护线程时，java虚拟机退出，该方法必须在启动线程前调用，写在main函数时，main主线程执行完，则退出
线程结束：public void stop：让线程停止，已经过时的函数。
public void interrupt：中断线程
线程的生命周期：
新建：创建线程对象
就绪：有执行资格，没有执行权
运行：有执行资格，有执行权
阻塞：由于一些操作可以让线程处于该状态，没有执行资格，没有执行权，而另一些操作可以把它激活，激活后处于就绪状态
死亡：线程对象变成垃圾，等待被回收
2.2 实现Runnable接口
1. 自定义类MyRunnable实现Runnable接口
2. 重写run()方法
3. 创建MyRunnable类的对象
4. 创建Thread类的对象，并把3步骤的对象作为构造函数传递
public static void main(String[] args){ MyRunnable my = new MyRunnable(); Thread my1 = new Thread(my); Thread my2 = new Thread(my); my1.setName("wangwang"); my2.setName("hahah"); my1.start(); my2.start(); } public class MyRunnable implements Runnable{ @Override public void run() { for(int x = 0; x < 100; x++){ System.out.println(Thread.currentThread().getName() + x); } } }
好处：可以避免由于java单继承带来的局限性
适合多个相同程序的代码去处理一个资源的情况，把线程通程序的代码，数据有效的分离，较好的体现了面向对象的设计思想
线程的安全性问题：
A：是否是多线程环境
B：是否有共享数据
C：是否有多条语句操作共享数据
public class SellTicket implements Runnable { private int tickets = 100; @Override public void run() { // TODO Auto-generated method stub while(true){ if(tickets > 0){ System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets-- + "张票"); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } } public class SellTicketsDemo { public static void main(String[] args){ SellTicket st = new SellTicket(); Thread t1 = new Thread(st); Thread t2 = new Thread(st); Thread t3 = new Thread(st); t1.start(); t2.start(); t3.start(); } }
上述的操作存在线程的安全性问题：
解决方法：把多条语句的共享数据包装成一个整体，当有线程在执行时，别的线程不能执行
同步代码块：synchronized(obj){}
public class SellTicket implements Runnable { private int tickets = 100; private Object obj = new Object(); @Override public void run() { // TODO Auto-generated method stub while (true) { synchronized (obj) { if (tickets > 0) { System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets-- + "张票"); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } } }
同步代码块的锁是任意的对象。
同步方法的格式以及锁的问题：this
静态方法的锁对象：对象名.class
线程安全的类:
StringBuffer,Vector,Hashtable
JDK5后出现的Lock锁的应用：
Lock(接口)：
void lock()：获取锁
void unlock()：释放锁
ReentrantLock是Lock的实现类
例火车票卖票：
public class SellTickesDemo { public static void main(String[] args){ SellTicket st = new SellTicket(); Thread t1 = new Thread(st); Thread t2 = new Thread(st); Thread t3 = new Thread(st); t1.start(); t2.start(); t3.start(); } } public class SellTicket implements Runnable { private int tickets = 100; private Lock lock = new ReentrantLock(); @Override public void run() { // TODO Auto-generated method stub while(true){ try{ lock.lock(); if(tickets > 0){ try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets-- + "张票"); } }finally{ lock.unlock(); } } } }
死锁问题的概述和使用：
同步的弊端：效率低，如果出现了同步嵌套，就容易出现死锁的问题
死锁的问题和代码：
指两个或者两个以上的线程在执行的过程中，因争夺资源而产生的一种互相等待的现象
public class MyLock { // 创建两把锁对象 public static final Object objA = new Object(); public static final Object objB = new Object(); }
public class DieLock extends Thread { private boolean flag; public DieLock(boolean flag){ this.flag = flag; } @Override public void run(){ if(flag){ synchronized(MyLock.objA){ System.out.println("if objA"); synchronized(MyLock.objB){ System.out.println("if objB"); } } }else{ synchronized(MyLock.objB){ System.out.println("else objB"); synchronized(MyLock.objA){ System.out.println("else obja"); } } } } }
public class DeadDemo { public static void main(String[] args){ DieLock d1 = new DieLock(true); DieLock d2 = new DieLock(false); d1.start(); d2.start(); } }
有可能产生死锁现象：此时的输出为：else objB if objA
多线程之间的通信问题：同步锁解决。
等待唤醒机制
生产者：是否有数据，如果有就等待，没有就生产，生产完通知消费者来消费
消费者：是否有数据，如果有就消费，没有就等待，通知生产者生产数据
Object提供了三个方法
wait():等待
notify():唤醒单个线程
notifyAll():唤醒所有线程，所以定义在object中
这些方法的调用必须通过锁对象来调用
锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入对象的synchronized方法之前必须先获得该对象的锁的拥有权，但是该对象的锁目前正被线程A拥有，所以这些线程就进入了该对象的锁池中。
等待池:假设一个线程A调用了某个对象的wait()方法，线程A就会释放该对象的锁后，进入到了该对象的等待池中
notify和notifyAll的区别
如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争
优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
循环里调用 wait 和 notify，不是在 If 语句
现在你知道wait应该永远在被synchronized的背景下和那个被多线程共享的对象上调用，下一个一定要记住的问题就是，你应该永远在while循环，而不是if语句中调用wait。因为线程是在某些条件下等待的——在我们的例子里，即“如果缓冲区队列是满的话，那么生产者线程应该等待”，你可能直觉就会写一个if语句。但if语句存在一些微妙的小问题，导致即使条件没被满足，你的线程你也有可能被错误地唤醒。所以如果你不在线程被唤醒后再次使用while循环检查唤醒条件是否被满足，你的程序就有可能会出错——例如在缓冲区为满的时候生产者继续生成数据，或者缓冲区为空的时候消费者开始小号数据。所以记住，永远在while循环而不是if语句中使用wait！
出处：https://blog.csdn.net/djzhao/article/details/79410229
举例：生产者和消费者：
public class Student { String name; int age; boolean flag; } public class GetThread implements Runnable { private Student s; public GetThread(Student s) { this.s = s; } @Override public void run() { // TODO Auto-generated method stub while (true) { synchronized (s) { while (!s.flag) { try { s.wait(); // 等待以后立即释放锁,上面使用while的区别在于执行完这个语句以后仍然会去判断条件是否满足 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(s.name + "-----" + s.age); s.flag = false; s.notify(); } } } } public class SetThread implements Runnable { private Student s; private int x = 0; public SetThread(Student s) { // TODO Auto-generated constructor stub this.s = s; } @Override public void run() { // TODO Auto-generated method stub while(true){ synchronized (s) { while(s.flag){ try { s.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (x % 2 == 0) { s.name = "xiaojignz"; s.age = 20; } else { s.name = "xiaoxiao"; s.age = 100; } x++; s.flag = true; s.notify(); } } } }
public static void main(String[] args){ Student s = new Student(); SetThread st = new SetThread(s); GetThread gt = new GetThread(s); Thread t1 = new Thread(st); Thread t2 = new Thread(gt); t1.start(); t2.start(); }
生产者和消费者改进版
public class Student { private String name; private int age; private boolean flag; public synchronized void set(String name, int age){ while(this.flag){ try{ this.wait(); }catch(InterruptedException e){ e.printStackTrace(); } } this.name = name; this.age = age; this.flag = true; this.notify(); } public synchronized void get(){ while(!this.flag){ try { this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println(this.name + "------" + this.age); this.flag = false; this.notify(); } } public class GetThread implements Runnable { private Student s; public GetThread(Student s) { this.s = s; } @Override public void run() { // TODO Auto-generated method stub while (true) { s.get(); } } } public class SetThread implements Runnable { private Student s; private int x = 0; public SetThread(Student s) { // TODO Auto-generated constructor stub this.s = s; } @Override public void run() { // TODO Auto-generated method stub while (true) { if (x % 2 == 0) { s.set("ha", 30); } else { s.set("wang", 20); } x++; } } } public class StudentDemo { public static void main(String[] args){ Student s = new Student(); SetThread st = new SetThread(s); GetThread gt = new GetThread(s); Thread t1 = new Thread(st); Thread t2 = new Thread(gt); t1.start(); t2.start(); } }
线程组：Java中使用ThreadGroup来表示线程组，它可以对一批线程进行分类和管理，Java允许程序直接对线程组进行控制,默认情况下，所有的线程都属于主线程组
获取当前线程组：public final ThreadGroup getThreadGroup()
设置线程组：Thread(ThreadGroup group, Runnable target, String name)
public class ThreadGroupDemo { public static void main(String[] args) { MyRunnable my = new MyRunnable(); ThreadGroup tg = new ThreadGroup("新组"); Thread t1 = new Thread(tg, my, "xiaojingzi"); Thread t2 = new Thread(tg, my, "xiaoxiao"); ThreadGroup t3 = t1.getThreadGroup(); ThreadGroup t4 = t2.getThreadGroup(); System.out.print(t3.getName() + "-----" + t4.getName() + "-----"); System.out.println(Thread.currentThread().getThreadGroup().getName()); tg.setDaemon(true); //没有明显的效果 t1.setDaemon(true); t2.setDaemon(true); t1.start(); t2.start(); } }
新组-----新组-----main xiaojingzi----0 xiaoxiao----0 xiaojingzi----1 xiaoxiao----1 xiaojingzi----2 xiaoxiao----2 xiaojingzi----3 xiaoxiao----3 xiaoxiao----4 xiaoxiao----5 xiaoxiao----6
线程池
程序器启动一个新的线程的成本是很高的，因为它设计到要与操作系统 进行交互，而使用线程池可以很高的提高性能，尤其是当程序中要创建大量的生存周期很短的线程时，更应该考虑使用线程池
JDK5新增Executors工厂类来产生线程池：
public static ExecutorService newCachedThreadPool();
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newSingleThreadExecutor()
这些方法的返回值都是ExecutorService对象，该对象表示一个线程池，可以执行Runnable对象或者Callable对象代表的线程，它提供了如下的方法：
Future<?> submit(Runnable task)
<T> Future<T> submit(Callable<T> task)
public class ExecutorsPoolDemo { public static void main(String[] args){ ExecutorService pool = Executors.newFixedThreadPool(2); pool.submit(new MyRunnable()); pool.submit(new MyRunnable()); pool.shutdown(); //用完以后等待可以回收继续使用，shutdown结束 } }
2.3 实现Callable接口（带泛型，依赖于线程池存在）
public class MyCallable implements Callable<Integer> { private int number; public MyCallable(int number){ this.number = number; } @Override public Integer call() throws Exception { // TODO Auto-generated method stub int sum = 0; for(int x = 0; x <= number; x++){ sum += x; } return sum; } } public class MyCallabelDemo { public static void main(String[] args) throws InterruptedException, ExecutionException{ ExecutorService pool = Executors.newFixedThreadPool(2); Future<Integer> f1 = pool.submit(new MyCallable(10)); Future<Integer> f2 = pool.submit(new MyCallable(20)); Integer i1 = f1.get(); Integer i2 = f2.get(); System.out.println(i1 + "-----" + i2); pool.shutdown(); } }
匿名内部类方式实现多线程程序
public class ThreadDemo { public static void main(String[] args){ new Thread(){ @Override public void run(){ for(int x = 0; x < 100; x++){ System.out.println(Thread.currentThread().getName() + "----" + x); } } }.start(); new Thread(new Runnable(){ @Override public void run(){ for(int x = 0; x < 100; x++){ System.out.println(Thread.currentThread().getName() + "----" + x); } } }){}.start(); } }
定时器：定时器是一个十分应用广泛的线程工具，可以用于调度多个定时任务以后台线程的方式执行，在java中，可以通过Timer和TimerTask类来实现定义调度的功能
Timer:
public Timer()
public void schedule(TimerTask task, long delay):安排在指定延迟后执行指定的任务
public void shcedule(TimerTask task, Date time)：安排在指定的时间执行指定的任务
public void schedule(TimerTask task, long delay, long period)：安排在指定的时间后指定的周期执行任务
public void scheduleAtFixedRate(TimerTask task, Date firstTime, long period)：安排指定的任务在指定的时间开始重复的固定延迟执行
public void cancel():终止此计数器，丢弃当前所有已经安排的任务
TimerTask:
public abstract void run()
public boolean cancel():终止此计时器，丢弃任何当前计划的任务。
public class TimerDemo { public static void main(String[] args){ Timer t = new Timer(); Timer m = new Timer(); // t.schedule(new MyTask(t), 3000); // t.schedule(new MyTask(), 3000, 2000); m.scheduleAtFixedRate(new MyTask(m), new Date(), 3000); } } class MyTask extends TimerTask{ private Timer t; public MyTask() { super(); // TODO Auto-generated constructor stub } public MyTask(Timer t) { super(); this.t = t; } @Override public void run(){ System.out.println("GG"); // t.cancel(); } }
3. 单例模式的饿汉式
public class RuntimeDemo { public static void main(String[] args) throws IOException{ Runtime r = Runtime.getRuntime(); r.exec("calc"); // 执行dos命令 } }