java多线程

Java多线程：

什么是进程？{
当前正在运行的程序。
代表一个应用程序在内存中的执行区域。
}


什么是线程(FlashGet)？{
是进程中的一个执行控制单元，执行路径。
（执行空间代码的执行者）
}

一个进程中至少有一个线程在负责控制程序的执行。
一个进程中如果只有一个执行路径，这个程序成为单线程程序。
一个进程中如果有多个执行路径时，这个程序成为多线程程序。

多线程的出现：可以有多条执行路径。让多部分代码可以完成同时执行。以提高效率。本身也是对问题的一种解决方案，比如图形界面的多个小程序同时执行。比如360，迅雷

Jvm启动是单线程还是多线程？{

Jvm的启动就是多线程程序。
其中有一个程序负责从主函数开始执行，并控制程序运行的流程。
同时为了提高效率，还启动了另一个控制单元(执行路径)专门负责堆内存中的垃圾回收，在程序正常执行的过程中，如果出现了垃圾，这时另一个负责收垃圾的线程会在不定时的时间内进行垃圾的处理。这两个程序是同时执行的。

}

负责执行正常代码的线程，称为主线程，该线程执行的代码都存放于主函数中。
负责收垃圾代码的线程，称为垃圾回收线程。该线程要执行的代码在finallize中。

如何在java中创建一个线程？{

其实java中对线程这类事物已经进行了描述，并提供了相对应的对象。
这个对象就是java.lang.Thread。

创建线程的两种方式
1.继承Thread类。
　　步骤：
　　1.定义类继承Thread
　　2.覆盖Thread类中run方法()
　　3.创建Thread类中的子类对象创建线程。
　　4.调用Thread类中的start方法开启线程，并执行子类中的run方法
　　特点：
　　1，当类去描述事物，事物中有属性和行为。如果行为中有部分代码需要被多线程 所执,行，同时还在操作属性。就需要该类继承Thread类，产生该类的对象作为线 程对象。可是这样会导致每一个对象中都会存储一份属性数据。
　　无法在多个线程中共享数据，加上静态，虽然实现了共享，但是生命周期过长。
2.如果一个类明确了自己的父类，那么就不可以继承Thread。因为java不允许类的多继承。

2.实现runnable接口。
　　步骤：
1.定义类实现Runnable接口。
2.覆盖接口中的run方法。(将多线程要运行的代码定义在方法中)
3.通过Thread类创建线程对象，并将实现了runnable接口的子类对象作为实际参数传递给Thread类的构造函数。
（为什么非要被Runnable接口的子类对象传递给你Thread类的构造函数呢？
　　是因为线程对象在建立时，必须要明确自己要运行的run方法，而这个run方 法定义在了Runnable接口的子类中，所以要将该run方法所属的对象传递给 Thread类的构造函数。让线程对象建立，就知道运行那个run方法。
）
4.调用Thread类中的start方法，开启线程，并执行Runnable接口子类中的run方法。
特点：
　　1.描述事物的类中封装了属性和行为，如果有部分代码需要被多线程所执行，
　　同时还在操作属性，那么可以通过实现Runnable接口的方式。因为该方式是定义一个Runnable接口的子类对象，可以被多个线程所操作。实现了数据共享。
2.实现了Runnable接口的好处，避免了单继承的局限性。一个类如果已经有了自己的父类，不可以继承Thread类。但是该类中还有需要被多线程执行的代码。这时就可以通过在该类上功能扩展的形式。实现一个Runnable接口。

　　所以创建线程时，尽量使用第二种方法。
　　
创建线程的两种方式区别？



(为什么要覆盖run？
直接建立Thread类对象即可，并开启线程执行就可以了，但是虽然线程执行了，可是执行的代码是该线程默认的代码，该代码就存放在run方法中。
可是定义线程的目的是为了执行自定义的代码。
而线程的运行代码都存储在run方法中，所以只有覆盖了run方法，才可以运行自定义的内容。想要覆盖，必须要先继承。

主线程运行的代码都在main函数中，自定义的代码都在run方法中。
)

(
**
直接创建Thread类的子类对象就是创建了一个线程，如果直接调用该对象的方法。这时，底层资源并没有完成线程的创建和执行，仅仅是简单的调用对象的方法。
在内存中其实：1.堆内存中产生了一个对象，2.需要调用底层资源去创建执行路径

如果想要开启线程：需要调用start方法，该方法做了两件事
1.开启线程
2.调用线程的run方法
)
}


当创建了两个线程后的d1,d2后，这时程序就有了三个线程在同时执行。
当主函数执行完d1.start(),d2.start()后，这时三个线程同时打印,结果比较杂乱。
这是因为线程的随机性造成的。
随机性的原理是：windows中的多任务同时执行，其实就是多个应用程序在同时执行。
而每一个应用程序都有线程来负责控制的。所以window就是一个多线程的操作系统，那么cpu是负责提供程序运算的设备。cpu在某一时刻只能执行一个程序，所谓的多任务执行就多个应用程序在执行，其实是cpu通过快速切换来完成的。 只是感觉上是同时而已。

能不能真正意义上的同时执行？{
可以，多个cpu，就是现在的多核。
}

线程中的方法：
多线程的创建，为了对各个线程进行标示，系统会自动对各个线程起一个名字（thread--）
Static Thread currentThread() 获取到当前线程
String getName() 得到当前线程的名称
Vodi setName() 重新设置线程的名称

如何获取到主线程？
可以通过Thread类中的一个方法：currentThread返回当前正在执行的线程对象。
主线程的名字叫main--


在线程被创建后，可以分为临时阻塞状态，运行状态，冻结状态，消亡状态。
如果有三个线程A,B,C;当三个线程都调用start方法之后，三个线程都具备了执行资格，
处于临时阻塞状态。
当某一个线程A正在被CPU处理，说明A处于运行状态，即具备了资格，也具备了CPU的执行权。
而B,C处于临时阻塞状态，当CPU切换到B线程时，B就具备执行权，这时，A,C就处于临时阻塞状态，只具备执行资格，不具备执行权。

当一个线程被cpu执行具备了执行权，就到了运行状态，当cpu切换到其他线程开始执行的时候，刚才的线程就失去了执行权，回到了临时阻塞状态。
当一个线程调用了sleep，wait方法后，就释放了cpu的执行权，并释放了执行资格。
冻结状态结束后，表示线程重新具备了执行资格，但是不一定立刻具备执行权。
比如睡眠时间到，或者用notify方法唤醒线程。

当一个线程执行完就到了消亡状态，也可以调用stop方法让线程进行消亡。




线程安全问题：（因为线程的随机性，有可能会导致多线程在操作数据时发生数据错误的情况）
线程安全问题产生的原因：
当线程多条代码在操作同一个共享数据时，一个线程将部分代码执行完，还没有继续其他代码时，被另一个线程获取cpu执行权，这时，共享数据操作就有可能出现数据错误。
简单说：多条操作功能数据的代码被多个线程分开执行造成的。
安全问题涉及的内容：
共享数据。
是否被多条语句操作。
这也是判断多线程程序是否存在安全隐患的依据。

解决安全问题的方式：
　　Java中提供了一个同步机制。
　　解决原理：让多条操作共享数据的代码在某一时间段，被一个线程执行完，在执行过程中，其他线程不可以参与运算。
　　
　　同步格式：
　　同步代码块：
　　Synchronized(对象){
　　需要被同步的代码
　　}
　　
　　同步的原理：通过一个对象锁，将多条操作共享数据的代码进行了封装并加锁。只有持有这个锁的线程才有机会进入同步中的去执行，在执行期间，即使其他线程获取到执行权。因为没有获取到锁，所以只能在外面等。只有同步中的线程执行完同步代码块中的代码，
　　出同步代码块时，才会释放这个锁，那么其他程序线程才有机会去获取这个锁，并只能有一个获取到而且进入到同步中。
　　
　　同步的好处：
　　同步的出现解决了多线程的安全问题
　　同步的弊端：
　　因为多个线程每次都要判断这个锁，所以效率会降低。
　　
　　加入了同步，安全问题有可能依然存在，
　　因为同步是有前提的：
　　1，同步必须是有两个或两个以上的线程才需要同步
　　2，必须要保证多个线程使用的是同一个锁，才可以实现多个线程被同步。
　　如果出现加上同步，安全问题依然存在，就按照两个前提来排查问题。

如何查看程序中有无线程安全隐患？{
1，查看线程代码中是否有共享数据。
2，这个共享数据有没有被多条语句所操作。
}

同步代码块时用于封装代码的，函数也用于封装代码，不同之处是同步带有
锁机制。那么如果让函数这个封装体具备同步的特性。就可以取代同步代码块。
同步函数：就是在函数上加上synchronized关键字。Public synchronized void add();

那么同步函数用的哪个锁？{
　　在同步代码块中用的是任意一个对象用来加锁，而同步函数中的锁用的是当前对象
　　，也就是this
}

同步函数和同步代码块的区别：{
同步代码块使用的锁可以是任意对象，
同步函数使用的锁是固定对象，this
所以一般定义同步时，建议使用同步代码块。
}

静态同步函数用的是哪个锁？{
　　静态同步函数使用的锁不是this，
　　因为静态函数中不可以定义this。
　　
　　静态随着类的加载而加载，这时有可能内容还没有该类的对象。
　　但是一个类加载进内存，会先将这个类对应的字节码文件封装成对象，
　　该对象的表示方式  类名.class 代表一个类字节码文件对象，
　　该对象在内存是唯一的。
　　
　　静态同步函数使用的锁就是，该类对应的字节码文件对象，也就是类名.class
}

死锁：
死锁经常出现的状况为：同步嵌套。

class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag = flag;
}
public void run()
{
if(flag)
{
while(true)
{
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName()+"...if......locka");
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName()+"...if......lockb");

}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName()+"...else..........lockb");
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName()+"...else..........locka");

}
}
}
}
}

}

class MyLock
{
public static Object locka = new Object();
public static Object lockb = new Object();
}


class DeadLockTest
{
public static void main(String[] args)
{
Test t1 = new Test(true);
Test t2 = new Test(false);

Thread th1 = new Thread(t1,"小强");
Thread th2 = new Thread(t2,"旺财");

th1.start();
th2.start();
}
}

线程间通信：
Wait():让线程等待，将线程存储到一个线程池中。
Notify():唤醒被等待的线程，通常都唤醒线程池中的第一个，让被唤醒的线程处于临时阻塞状态。
notifyAll():唤醒所有的等待线程，将线程池中的所有线程都唤醒，让他们从冻结状态转到临时阻塞状态。

这三个方法用于操作线程，但是都定义在Object类中：
因为，这三个方法在使用的时候，都需要定义在同步中，要明确这些方法所操作的线程所属于锁。例如A锁被wait的线程，只能被A锁的notify方法唤醒。
所以必须要表示wait，notify方法所属的锁对象，而锁对象可以是任意的对象。可以被任意的对象调用的方法肯定定义在Object类中。

**等待唤醒机制，通常都用在同步中，因为需要锁的支持。而且必须要明确wait，notify锁作用的锁对象。

在java.util.concurren.locks包中提供了一个接口Lock。代替了synchronized。
Synchronized使用的隐式锁
Lock使用的是显示的锁。
Lock（）获取锁
Unlock（）释放锁

还有一个对象Condition。
该对象的出现替代了Object中的wait，notify，notifyAll这些操作监视器的方法
替代后await，signal，signalAll。

**新功能最大的好处就是在一个lock锁上可以添加多组监视器对象，这样就可以实现
本方只唤醒对方的现象。

Sleep和wait的区别？{
1，sleep方法必须指定时间
2，wait方法有重载形式，可以指定时间，也可以不指定

对于执行权和锁的操作：
1，sleep():释放执行权，不释放锁，因为肯定能恢复到临时阻塞状态
2，wait():释放执行权，释放锁，因为wait不释放锁，如果没有时间指定，那么其他线程都进行不了同步中，无法将其唤醒。

（同步中可以有多个存活的线程，但是只能有一个执行同步的代码，因为只有一个线程会持有同步锁，只有当该线程释放了锁，其他线程才有机会获取到锁，而且只能用一个线程获取到锁，继续执行。）
}

如何让线程停止？
1，使用Thread类中的stop方法。（强制结束，已过时）
2，线程执行的代码结束。

通常定义线程代码都有循环，因为需要单独开辟一个执行路径去重复很多事情。既然有循环，控制住循环，就可以结束run方法。
定义标记可以结束线程，但是如果线程在运行过程中处于了冻结状态，没有执行到标记，这时，可以通过Thread类中的interrupt方法中断线程的冻结状态。强制让其恢复到运行状态中来，就可以有机会执行标记，但是这种强制动作会发生异常。

setDeamo(boolean):可以将线程标记为后台线程。
线程分前台和后台两种。运行方式都一样都会获取cpu的执行权执行
不同的在于，结束的方式不同。
前台线程只有run方法结束，才结束。
后台线程，run方法结束，结束，还有，如果run方法没结束，而前台线程都结束了，后台线程也结束。
所以一个进程是否结束参考的是，是否还有前台线程存活，如果前台线程都结束了，那么进程也就结束了。


当有了join方法以后，该t1线程会全部执行完，其他线程才可以执行。
Join：临时加入一个线程进行执行。
例如，当主线程获取到了cpu的执行权，执行时，执行到了A线程的join方法。
这时就知道A线程要加入进来执行，那么A执行就需要cpu的执行权。而这时cpu的执行权在主线程持有，主线程会释放自己的执行权。让A线程进行执行，只有等A线程执行完以后，主线程才会执行，此时主线程就处于冻结状态。

一般使用情况：当在线程执行过程中，需要一个运算结果时，可以通过加入一个临时线程，将该结果进行运算，这时需要结果的线程处于冻结状态，当加入的线程执行完，该线程在继续执行。