----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
概念：
多线程：在一个 程序 中，这些独立运行的程序片段叫作“线程”，利用它编程的概念就叫作“多线程处理”。
现在的操作系统是多任务操作系统。多线程是实现多任务的一种方式。进程是指一个内存中运行的
应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows
系统中，一个运行的exe就是一个进程。 线程是指进程中的一个执行流程，一个进程中可以运行多个
线程。比如java.exe进程中可以运行很多线程。线程总是属于某个进程，进程中的多个线程共享进程
的内存。“同时”执行是人的感觉，在线程之间实际上轮换执行。
进程：是一个执行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径或者叫一个控制
单元。
线程：就是进程中的一个独立控制单元，线程在控制着进程的执行。程序中的执行线程，Java 虚拟机允许
应用程序并发地运行多个执行线程。
在java中创建新执行线程有两种方法。
一种方法是将类声明为 Thread 的子类。该子类应重写Thread 类的 run 方法。接下来可以分配并启动
该子类的实例。例如，计算大于某一规定值的质数的线程可以写成：
class PrimeThread extends Thread
{
long minPrime;
PrimeThread(long minPrime)
{
this.minPrime = minPrime;
}
public void run() {
// compute primes larger thanminPrime
. . .
}
}
然后，下列代码会创建并启动一个线程：
PrimeThread p = new PrimeThread(143);
p.start();
另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，
在创建Thread 时作为一个参数来传递并启动。采用这种风格的同一个例子如下所示：
class PrimeRunimplements Runnable
{
longminPrime;
PrimeRun(long minPrime)
{
this.minPrime = minPrime;
}
publicvoid run()
{
//compute primes larger than minPrime
. . .
}
}
然后，下列代码会创建并启动一个线程：
PrimeRun p =new PrimeRun(143);
newThread(p).start();
范例1：
{
private String name;
public hello(String name)
{
this.name= name;
}
public void run()
{
for (int i = 0; i < 5; i++)
{
System.out.println(name+ "运行 " + i);
}
}
public static void main(String[]args)
{
helloh1=new hello("A");
helloh2=new hello("B");
h1.start();
h2.start();
}
}
然后运行程序，输出的可能的结果如下：
A运行 0
B运行 0
B运行 1
B运行 2
B运行 3
B运行 4
A运行 1
A运行 2
A运行 3
A运行 4
范例2：
class hello implements Runnable
{
private String name;
public hello()
{
}
public hello(String name)
{
this.name =name;
}
public void run()
{
for (int i = 0; i < 5; i++)
{
System.out.println(name +"运行 " + i);
}
}
public static void main(String[] args)
{
hello h1=new hello("线程A");
Thread demo=new Thread(h1);
hello h2=new hello("线程Ｂ");
Threaddemo1=new Thread(h2);
demo.start();
demo1.start();
}
}
然后运行程序，输出的可能的结果如下：
线程A运行 0
线程Ｂ运行 0
线程Ｂ运行 1
线程Ｂ运行 2
线程Ｂ运行 3
线程Ｂ运行 4
线程A运行 1
线程A运行 2
线程A运行 3
线程A运行 4
在实际使用上实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源。
2）：可以避免java中的单继承的限制。
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立。
注意事项：
1.多线程的执行具有随机性。
2.虽然我们在这里调用的是start（）方法，但是实际上调用的还是run（）方法的主体。
3.覆写run方法的目的是为了修改run方法内的代码，成为我们需要的代码，将自定义的代
码存储到run方法中，让线程去运行。也就是run方法有封装线程要运行代码的效果。
4.如果直接使用对象.run来调用run中的代码，则不会开启线程，主线程会执行run中的代码。
线程的状态转换
线程可以分为4个状态：
1.New(新生)。
2.Runnable(可运行)：为了方便分析，还可将其分为：Runnable与Running。
3.blocked(被阻塞)。
4.Dead(死亡)。
1，新生线程：
当你用new操作符创建一个线程时，例如用new Thread(r)，线程还没有开始运行，此时线程处于新生状态。
2，可运行线程：
（a）Runnable：一旦调用了start方法，就进入到Runnable状态。
（b）Running：在到Runnable后，线程就有可能已经进入到了运行状态；根据操作系统所提供的服务，在抢
占式调度的系统中，系统给每个运行的线程一个时间片来处理任务，而这个时间片用完后，操作系统
将剥夺该线程的资源。这样，在Runnable与Running之间是可以相互转换的。所以从大的分类，这两个
是可以合并的。
3，被阻塞线程：
（1），当线程通过调用sleep方法进入睡眠状态时。（类似的方法有yield()，join()，）
！！：Thread.sleep（）；出现的异常只能try，不能抛，因为run方法是覆写的，而父类和接口都没
有抛出异常，所以只能try不能抛。
（2），当线程通过调用wait方法时，进入阻塞。
（3），当线程调用的对象，试图得到这个对象的锁，而该锁已经被其他线程持有。
而从被阻塞状态到可运行状态。
（1），sleep睡眠时间已过。
（2），在调用wai方法后，又通过notify或notifyAll方法唤醒。
（3），对象锁已经释放。
4，死线程
（1），因为run方法正常退出而自然死亡。
（2），因为一个未捕获的异常终止了run方法而使线程猝死。
同步代码：
synchronized（对象）
｛
要同步的代码；
｝
同步的前提：1.拥有2个或者2个以上的线程。
2.必须是多线程使用一个锁。
注意事项：
1.对象如同锁，持有锁的线程可以在同步中执行，没有锁的线程，即使获取执行权限也不能在
同步中执行，因为没有持有锁。
2.同步中只能有一个线程在运行。
3.对象通常使用Object的对象，默认为1的状态，当一个线程进入后，会优先把1变成0，上锁，
然后去执行代码，执行完后在将0变成1，打开锁，让下一个程序进入。
查找多线程中的问题：
1.明确那些代码是多线程运行代码。
2.明确共享数据。
3.明确多线程运行代码中哪些语句是操作共享数据的。
同步函数：
权限修饰符 synchronized 返回值类型/void 函数名（）｛｝
1.不能将函数全部同步，要查找需要同步的代码，单独封装进行调用。
2.同步函数的锁是this，因为函数被对象调用，那么函数都有一个所属对象引用，
就是this，所以同步函数的锁是this。
静态同步函数：
1.如果同步函数被静态锁修饰，那么锁是class对象。
2.因为静态进去内存的时候，内存中没有本类对象，但是一定会有该类对应的字节码
文件对象（类名.class），所以该锁就是该类的class文件。
延时加载的单例设计：懒汉式
classSingle
{
private static Single s = null;
private Single()
{
}
public static SinglegetInstance()
{
if(s==null)
{
synchronized(Single.class)
{
if(s==null)
{
s=newSingle();
}
}
}
return s;
}
}
特点：实例的延时加载。
因为懒汉式在使用多线程的，会出现安全问题，所以使用同步来解决。
单纯的使用同步会使懒汉式的运行效率变低，所以加双重判断来提高效率。
使用的同步锁为该类所属的字节码文件对象。
死锁：
是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，
若无外力作用，它们都将无法推进下去。
产生死锁的原因：
1.因为系统资源不足。
2.进程运行推进的顺序不合适。
3.资源分配不当。
死锁是因为多线程访问共享资源，由于访问的顺序不当所造成的，通常是一个线程锁定了一个资
源A， 而又想去锁定资源B；在另一个线程中，锁定了资源B，而又想去锁定资源A以完成自身的操作，
两个线程都想得到对方的资源，而不愿释放自己的资源，造成两个线程都在等待，而无法执行的情况。
分析死锁产生的原因可以看出是由访问共享资源顺序不当所造成的。
为了避免死锁，会在wait和notify前面加上对象名表示是持有当前调用对象的锁。
停止线程：
1.只有一种，就是run方法结束。
2.开启多线程运行，运行代码通常是循环结构。
只要控制住循环，就可以让run方法结束，也就代表线程结束。
3.使用interrupt（中断）方法，该方法是结束线程的冻结状态，使线程回来运行状态来。（会出现异常）
4.特殊情况，当线程处于了冻结状态，就不会读取到结束标记，那么程序就不会结束，当没有指定的方式
让冻结的线程恢复到运行状态时，就需要对冻结进行清除，强制让线程恢复发哦运行状态来，这样就可
以操作结束标记让线程结束。
守护线程：
守护线程则是用来服务用户线程的。是运行在后台的一种特殊进程。它独立于控制终端并且周期性地
执行某种任务或等待处理某些发生的事件。
1.void setDaemon（boolean on）； 如果为ture则该线程标记为守护线程。
2.该方法必须在启动线程前调用。
3.当运行的线程都是守护线程的时候，java虚拟机退出。
4.该方法首次调用该线程的checkAccess方法，不带任何参数。
5.如果该线程处于活动状态则会抛出异常：IllegalThreadStateException
6.如果当前线程无法修改该线程则会抛出异常：SecurityException
----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------
525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
