有关线程的所有总结

多线程：
线程：进程中的一个控制流程单元。
一个进程中至少有一个线程。
只有一个线程的程序，称为单线程。
有多个线程的程序，称为多线程。

开启多线程有什么好处？
1，提高效率，原理就是在合理使用cpu资源。
2，可以让多部分代码同时执行。

创建示例：聊天程序，接收和发送就是需要同时执行的。
线程的特性：随机性。原理：其实是cpu不断的进行时间片的切换。

想要在Java语言中使用多线程技术，Java对线程这类事物进行描述。
提供了一个对象：Thread。

有一点必须明确：只有Thread类或者Thread类的子类对象才可以调用系统资源创建控制单元。
创建线程的两种方式：
1，继承Thread类。
1.1继承Thread，
1.2复写run方法，将多线程需要运行的代码存入该方法中。
1.3创建Thread的子类对象，(创建线程)
1.4调用start方法开启线程。(start方法做了两个动作，开启线程，调用run方法。)
2，实现Runnable接口。
2.1实现Runnable接口。
2.2复写接口中的run方法。
2.3创建Runnable接口的子类对象。
2.4创建Thread类的对象(创建线程)
2.5将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
原因：多线程去执行指定的run方法。
2.6调用Thread类的start方法开启线程。

class Demo implements Runnable
{
public void run()
{
System.out.println("demo run");
}
}

main()
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}

两种方式的区别：
1，实现方式和继承方法使用的run方法的位置不同。
2，实现方法避免了单继承的局限性。

线程的生命周期：
1，被创建。new
2，可运行。start
3，冻结。线程还活着，但是cpu不执行它。sleep,wait.
4，消亡。线程挂了。stop,run结束。(线程执行代码结束，线程就停止)

线程安全问题。
引发原因：
当线程运行的代码中有对成员变量(共享数据)进行多次操作时，就有可能引发安全问题。
因为多条操作同一资源的语句被多个线程分开运行就会发生。

int tick = 100;

run()
{
if(tick>0)
tick--;
}

解决的原理：只要在同一时间段，只让一个线程将这些操作同一资源的代码执行完即可。
这执行过程，其他的线程不可以参与执行该代码。

java提供了同步方式来完成线程安全问题的解决.

1，同步原理：
其实就是通过带锁的代码块将容易出现安全问题的代码进行封装。

2，同步好处：
解决了线程安全问题。
3，同步弊端：
1，降低了运行效率。(判断锁是较为消耗资源的)
2，同步嵌套，容易出现死锁。

4，同步的表现形式：
1，同步代码块。
synchronzied(对象锁){
需要被同步代码。（哪些需要同步哪些不需要一定要分清）
}
2，同步函数。
就是在函数上加了synchronzied关键字进行修饰。、
同步代码块可以使用任意对象作为锁。
同步函数使用的锁只有一个，就是this。

注意：static同步函数使用的锁是该函数所属类的对象。 类名.class

5，同步前提：
1，必须是两个或者两个以上的线程。
2，多个线程必须使用同一个锁。

有一个比喻：火车上的卫生间。

单例设计模式中的懒汉式：
class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
s = new Single();
}
}

return s;
}
}

线程间的通信。

两个或者两个以上的线程在处理同一个资源时，处理动作是不一样的。
这时就需要将动作代码分别存放在不同的run方法，而run方法要封装单独的类中。

示例：生产者，消费者。
在同步中的使用的方法。
wait，notify，notifyAll。这三个方式都定义Object类中。
wait：让当前线程处于等待(冻结状态)状态。将该线程存入到了线程池中。
notify：唤醒被等待的线程。通常唤醒的是线程池中的第一个。
notifyAll：唤醒线程池中所有被等待线程。

这些方法要用在同步中。并要明确三个方法所属的同步锁。
synchronized(obj)
{
obj.wait();

obj.notify();

}

在同步中无论被等待多少个线程，同时唤醒后，
注意：只可能有一个线程会持有锁，并执行。其他线程即使子啊同步块中，也执行不了。
wait():释放cpu的执行权。释放锁。
sleep():释放cpu的执行权。不释放锁。

线程类中的常见方法：
1，线程名称，通过Thread类的构造函数，指定名称，或者通过setName来完成。
2，优先级：setPriority(int);MAX_PRIORITY,MIN_PRIORITY,NORM_PRIORITY
3，将线程标记为守护线程(后台线程)：setDaemon(true);注意该方法要在线程开启前使用。
和前台线程一样开启，并抢资源运行，
所不同的是：当前台线程都结束后，后台线程会自动结束。无论后台线程处于什么状态都会自动结束。
4，join方法：让线程加入执行。执行某一线程join方法的线程会被冻结。
等待某一线程执行结束，该线程才会恢复到可运行状态。
5，yield():可以对线程进行临时暂停，其实就是让线程临时将资源释放出来。
结束线程。
stop方法因为安全原因，以后过时。
所以结束线程原理就一个：就是让run方法结束。而run方法中通常会定义循环结构。
所以只要控制住循环即可。
那么可以boolean标记的形式完成。
只要在某一情况下将标记改变，让循环停止即可让线程结束。
但是，特殊情况，线程在运行过程中，处于了冻结状态，是不可能读取标记的。
那么这时，可以通过正常方式恢复到可运行状态，
也可以强制让线程恢复到可运行状态，通过Thread类中的，
interrupt():清除线程的冻结状态，但这种强制清除会发生InterruptedException.
所以在使用 wait，sleep，join方法的时候都需要进行异常处理。
多线程在开发中的应用：
1，下载。
2，聊天。
3，多个客户端访问web服务器的时候，web服务器会将客户端的请求封装到一个线程中。
这样多个客户端请求才可以同时访问web服务器，并运行web服务器程序。

多线程在代码中的体现形式之一：
class Demo
{
public static void main(String[] args)
{

new Thread()
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println("a="+x);
}
}
}.start();

for(int x=0; x<100; x++)
{
System.out.println("b="+x);
}

Runnable r = new Runnable()
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println("c="+x);
}
}
};
new Thread(r).start();

}
}

什么时候使用多线程呢？
当多部分代码需要同时执行的时候，就使用多线程技术。