一、多线程
线程是CPU调度和分派的基本单位，一个进程可以由多个线程组成，而这多个线程共享一个存贮空间。多线程指单个程序可以通过运行多个不同线程来提高程序的处理效率。即多个线程处理同一个任务，就如多个人做同一件事。
1、线程概述：
1)要理解多线程，就必须理解线程。而要理解线程，就必须知道进程。
进程：是一个正在执行的程序。每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。
线程： 就是进程中的一个独立的控制单元。线程在控制着进程的执行。只要进程中有一个线程在执行，进程就不会结束。一个进程中至少有一个线程。
2)多线程
在java虚拟机启动的时候会有一个java.exe的执行程序，也就是一个进程。该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在于main方法中。该线程称之为主线程。JVM启动除了执行一个主线程，还有负责垃圾回收机制的线程。像种在一个进程中有多个线程执行的方式，就叫做多线程。
3)多线程存在的意义
多线程的出现能让程序产生同时运行效果。可以提高程序执行效率。
例如：在java.exe进程执行主线程时，如果程序代码特别多，在堆内存中产生了很多对象，而同时对象调用完后，就成了垃圾。如果垃圾过多就有可能是堆内存出现内存不足的现象，只是如果只有一个线程工作的话，程序的执行将会很低效。而如果有另一个线程帮助处理的话，如垃圾回收机制线程来帮助回收垃圾的话，程序的运行将变得更有效率。
4)线程的五个状态
被创建：创建Thread类极其子类对象。
运行：正在运行的状态。
冻结：正常（运行）状态通过sleep()和wait()方法。即一个线程放弃执行资格。被唤醒后，此线程要先转换到阻塞状态。
临时阻塞：具备运行资格，但没抢到CPU执行权。
消亡：（1）运行状态通过stop()方法。（2）线程执行结束
2、创建线程的方式
创建线程共有两种方式：继承方式和实现方式（简单的说）。
1)继承方式：继承Thread类，覆盖run()方法。
创建步骤：
a，定义类继承Thread。
b，复写Thread中的run方法。
目的：将自定义代码存储在run方法中，让线程运行。
c，创建定义类的实例对象。相当于创建一个线程。
d，用该对象调用线程的start方法。该方法的作用是：启动线程，调用run方法。
注：如果对象直接调用run方法，等同于只有一个线程在执行，自定义的线程并没有启动。
覆盖run方法的原因：
Thread类用于描述线程。该类就定义了一个功能，用于存储线程要执行的代码。该存储功能就run方法。也就是说，Thread类中的run方法，用于存储线程要运行的代码。
代码示例：
class ThreadTest extends Thread{
public void run(){
线程运行代码;
}
}
class Test{
public static void main(String[] args){
ThreadTestthread = new ThreadTest();
thread.start();
}
}
也可以使用匿名类的方式来创建：
class Test{
public static void main(String[] args){
new Thread(){
public void run(){
线程运行代码;
}
}.start();
}
}
2)实现方式
使用继承方式有一个弊端，那就是如果该类本来就继承了其他父类，那么就无法通过Thread类来创建线程了。这样就有了第二种创建线程的方式：实现Runnable接口，并覆盖其中run方法的方式。
创建步骤：
a，现Runnable的接口。
b，覆盖Runnable接口中的run方法。目的也是为了将线程要运行的代码存放在该run方法中。
c，通过Thread类创建线程对象。
d，将Runnable接口的子类对象作为实参传递给Thread类的构造方法。
e，调用Thread类中start方法启动线程。start方法会自动调用Runnable接口子类的run方法。
实现方式好处：避免了单继承的局限性。在定义线程时，建议使用实现方式。
代码示例：
class RunnableTest implements Runnable{
public void run(){
线程运行代码;
}
}
class Test {
public static void main(String[] args){
RunnableTest runnableTest = new RunnableTest();
Thread thread = new Thread(runnableTest);
thread.start();
}
}
匿名类方式：
class Test{
public static void main(String[] args){
new Thread(new Runnable(){
public void run(){
线程运行代码;
}
}).start();
}
}
3、线程安全问题
1)导致安全问题的出现的原因：
当多条语句在操作同一线程共享数据时，一个线程对多条语句只执行了一部分，还没用执行完，另一个线程参与进来执行。导致共享数据的错误。
简单的说就两点：
a)多个线程访问出现延迟。
b)线程随机性。
注：线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。
2)解决办法——同步
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
在java中对于多线程的安全问题提供了专业的解决方式——synchronized（同步）
这里也有两种解决方式，一种是同步代码块，还有就是同步函数。都是利用关键字synchronized来实现。
a)同步代码块
用法： synchronized（对象）
{需要被同步的代码}
同步可以解决安全问题的根本原因就在那个对象上。其中对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
代码示例：
//给卖票程序示例加上同步代码块。
class Ticket implements Runnable{
private int tick=100;
Object obj = new Object();
public void run(){
while(true){
//给程序加同步，即锁
synchronized(obj){
if(tick>0){
try{
//使用线程中的sleep方法，模拟线程出现的安全问题
//因为sleep方法有异常声明，所以这里要对其进行处理
Thread.sleep(10);
}
catch (Exception e){}
//显示线程名及余票数
System.out.println(Thread.currentThread().getName()+"..tick="+tick--);
}
}
}
}
}
b)同步函数
格式：在函数上加上synchronized修饰符即可。
那么同步函数用的是哪一个锁呢？
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。
代码示例：
class Ticket implements Runnable{
private int tick=100;
Object obj = new Object();
public void run(){
while(true){
show();
}
}
//直接在函数上用synchronized修饰即可实现同步
public synchronized void show(){
if(tick>0){
try{
//使用线程中的sleep方法，模拟线程出现的安全问题
//因为sleep方法有异常声明，所以这里要对其进行处理
Thread.sleep(10);
}
catch (Exception e){}
//显示线程名及余票数
System.out.println(Thread.currentThread().getName()+"..tick="+tick--);
}
}
}
3)同步的前提
a)必须要有两个或者两个以上的线程。
b)必须是多个线程使用同一个锁。
4)同步的利弊
好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。
5)如何寻找多线程中的安全问题
a)明确哪些代码是多线程运行代码。
b)明确共享数据。
c)明确多线程运行代码中哪些语句是操作共享数据的。
4、静态函数的同步方式
如果同步函数被静态修饰后，使用的锁是什么呢？
通过验证，发现不在是this。因为静态方法中也不可以定义this。静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。如：
类名.class 该对象的类型是Class
这就是静态函数所使用的锁。而静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class
经典示例：
//加同步的单例设计模式————懒汉式
class Single{
private static Single s = null;
private Single(){}
public static void getInstance(){
if(s==null){
synchronized(Single.class){
if(s==null)
s = new Single();
}
}
return s;
}
}
289
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
