多线程--java
多线程
单核cpu没有并行，它只不过是CPU时钟调度给你错觉，让你误以为他们真的在同一时间同时运行。
多核cpu才有并行
每一个task就是一个进程(Process), 在每一个process中至少有一个线程(Thread)在运行， 有时线程也称为轻量级的进程
每个thread ， 都有自己的局部变量表，程序计数器以及各自的生命周期
java每创建一个Thread就创建一个线程，java创建的线程默认是处于非阻塞状态，异步通信机制，以及线程内存共享
下面是一个简单的并行，sayhi(),sayno()为两个静态方法，下面有两个线程，一个lambada表达式，一个是main
syano也是如此，添加sleep(100)的原因是 10个for循环可能就是一毫米的事情
private static void sayhi(){ for(int i=0;i<10;i++){ System.out.println("hi"); try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
阻塞非阻塞是程序等待调用结果的状态
阻塞调用: 没立即得到结果，当前线程会被挂起 ，也就是处于阻塞状态
非阻塞调用：没立即得到结果，不会阻塞当前线程
同步异步是消息通信机制
同步： 等阻塞调用得到返回结果后，才返回I/O系统
异步：因为不阻塞当前线程，立即返回I/O系统，CPU可以去处理其它线程，等收到返回结果后，再去处理该线程
默认都是非阻塞调用，异步通信机制，因为它可以大大提高CPU性能。
为了更高效地减小线程的开销，多个线程可以对同一个内存资源共享调用，但会造成线程不安全
线程不安全：(多线程和单线程运行的结果不一样)
解释： 多线程调用与单线程(加锁)调用相同内存资源的结果不一样
线程安全：(每次运行的结果和单线程运行的结果是不一样的，而且其他的变量的值也和预期的是一样的)
加锁，通过加synchronized ，使某程序不能内存共享，阻塞调用，异步通信机制，所以对相同内存只能单线程运行。
注意：对不同内存资源是多线程。
也就是说加锁只对于线程访问相同内存资源，对于访问不同的内存资源不影响
对线程访问同一个内存资源代码不加锁
对线程访问同一内存资源加锁
对同一内存资源可以是 方法，代码块，对象
synchronized 修饰方法
如上图所示
synchronized 修饰代码块
synchronized(this){
//**代码块**//
}
synchronized 修饰对象
synchronized(MultiThreading.class){
}
synchronized(对象名){
}
线程的五种状态
创建状态 NEW
创建了线程对象，已经有相应的内存空间，但处于不可运行状态。 例如：Thread thread=new Thread()
就绪状态 RUNNABLE
启动了线程，也就是 start(),已经在JVM中创建了线程，但是还在等待CPU的调度 (线程的运行都听从于CPU的调度)
运行状态 RUNNING
线程获得CPU的执行，注意线程只能从runnable 到 running
在该状态中，可以发生如下转换：
- 直接进入TERMINATED状态， 比如已经弃用的stop(),判断中断标识来判断是否中断线程interrupt()
- 进入BOLOCKED状态，比如调用了sleep, wait方法，进行某个阻塞的IO操作，获得某个锁资源
- 进入RUNNABLE状态， 比如由于CPU的调度器轮询使该线程放弃执行， 线程主动调用yield方法，放弃CPU执行权
阻塞状态 BOLOCKED
该线程处于阻塞状态。sleep() , suspend(), wait()等会使线程进入阻塞状态，直到过了sleep()时间，调用resume()，调用notify()等
在该状态下可切换至如下几个状态：
- 直接进入TERMINATED状态
- 线程阻塞状态结束，比如过了sleep()时间，notify/notifyall唤醒等进入RUNNABLE状态
TERMINATED
一个线程的最终状态
suspend() 与 resume() 暂停与暂停后继续
run()中加入suspend()，程序运行到suspend()后，线程中断，进入阻塞状态，等到线程对象调用sleep()与resume()后,线程继续
suspend()不会释放所持锁，如果resume()在suspend()之前，会造成死锁，已弃用
//i==3时会停一秒钟，再输出3，4，5
//如果注释掉resume(),程序将输出1,2 然后一直处于等待状态
public class MultiThreading implements Runnable{ @Override public synchronized void run() { for (int i = 1; i <= 5; i++) { if (i ==3) { Thread.currentThread().suspend(); } System.out.println(String.format("i：%s 线程：%s", i, Thread.currentThread().getName())); } } public static void main(String args[]) throws InterruptedException { MultiThreading a = new MultiThreading(); Thread one = new Thread(a); one.start(); Thread.sleep(1000); one.resume(); } }
wite() 与 notify()
wait() 与 notify() 必须要在相同对象锁下调用(在synchronized(){}内调用)，不然会抛出java.lang.IllegalMonitorStateException的异常
synchronized(this) 指当前对象， synchronized(对象) 指该对象锁
wait()与notify()是Object对象就有的，也就是说所有对象都有
调用wait() 会释放该锁，该线程进入阻塞，但是其它线程可以接管该锁； 不同于suspend() ,suspend()不会释放锁，线程会一直挂在那并且其它线程无法继续访问与它的相同内存资源，直到等到resume()；
wait()相比于suspend()不会造成死锁
join()
等待该线程完成后，才能继续运行join()之后的程序
加锁下输出1~10
public class MultiThreading implements Runnable{
public synchronized void run() {
int i=1;
while(i<10) {
i++;
}
}
public static void main(String[] args) {
MultiThreading a = new MultiThreading();
Thread threadOne = new Thread(a);
Thread threadTwo = new Thread(a);
threadOne.start();
threadTwo.start();
}
}
结果是1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9
它只能先执行完threadOne ,然后再执行threadtwo
加锁并加wait()与notify() 使输出结果为 112233445566778899
public class MultiThreading implements Runnable{
public synchronized void run() {
int i=1;
while(i<10) {
this.notifyAll();
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(i);
i++;
}
this.notifyAll();
}
public static void main(String[] args) {
MultiThreading a = new MultiThreading();
Thread threadOne = new Thread(a);
Thread threadTwo = new Thread(a);
threadOne.start();
threadTwo.start();
}
}
通过往实现的Runnable接口的类 加入对象锁 Object lock ,
实现多个线程的调度
如下是输出 1212121212121212
public class MultiThreading implements Runnable{
private int num;
private Object lock;
public MultiThreading(int num,Object lock) {
this.num = num;
this.lock=lock;
}
public void run() {
synchronized(lock) {
int i=1;
while(i<10) {
lock.notifyAll();
try {
lock.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(num);
i++;
}
lock.notifyAll();
}
}
public static void main(String[] args) {
Object lock =new Object();
MultiThreading a_one = new MultiThreading(1,lock);
MultiThreading a_two = new MultiThreading(2,lock);
Thread threadOne = new Thread(a_one);
Thread threadTwo = new Thread(a_two);
threadOne.start();
threadTwo.start();
}
}
不加wait()与notify()的结果是 先执行完线程threadOne,后执行threadTwo
