----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------
由于以前工作不曾使用过多线程技术，而通过最近一段时间的学习，可能学的东西还很片面。使用起来也很生疏，为了能更好的记忆和理解，我来把我最近一段时间学习的东西做一些整理。
首先，对于多线程技术，我们要明白如下的定义：
1.什么是进程？
进程就是正在进行中的程序，也就是对应一个应用程序在内存中所使用的空间。
2. 什么是线程？
线程就是进程中用于控制程序执行的控制单元(执行路径，执行情景)，而一个进程中至少要有一个线程。
3.什么是多线程
多线程就是一个进程中有多个(两个或两个以上)执行路径(控制单元)。
注意：对于JVM，启动时，就有两个线程：
1.jvm的主线程，也就是执行mian函数的线程。
2.jvm的垃圾回收线程。
创建线程的目的：就是开启一条线程，去运行指定的代码（线程要执行的代码），并且和其他代码同时运行，以达到多个线程来实现多任务并发，提高程序的执行效率。
那么，我们怎么来创建线程呢？在Java中提供了两种线程的方式：
一．继承Thread类
注：java提供的对线程描述的类是Thread类, 创建线程对象的方法是构造函数,提供了要被线程执行的代码存储的位置是在run()里面。
步骤：
1.继承Thread类。
2.覆盖run方法，将线程要运行的代码定义其中。（要覆盖run方法的原因是，定义线程要运行的代码存储在run()里面）
3.创建Thread类的子类对象，其实就是在创建线程，调用start方法（其中，start()有两个功能：1.开启线程 2.执行run()方法）。
class ThreadDemo extends Thread// 方法局限性,不能再继承其他父类.
{
private String name;
ThreadDemo(String name){
//super(name);Thread中的构造函数，可以给线程自定义名字。
this.name=name;
}
publicvoid run() {
System.out.println(this.name+" Thread run...");
}
publicstaticvoid main(String[]args){
ThreadDemo t1=new ThreadDemo("线程一");
ThreadDemo t2=new ThreadDemo("线程二");
t1.start(); //开启线程，调用run方法
t2.start();
}
}二．实现Runnable接口
注：下面的3种情况，就不可以再使用继承Thread类。
1.自定义的类中有多线程要运行的代码。但是该类有自己的父类。
2.要求程序具有功能的可扩展性。
3.多个功能使用一个共享数据。
那么，程序就提供了一个规则。通过实现Runnable接口。并将多线程要运行的代码存放在实现了Runnable类的子类的run方法中，然后调用对应的线程，进行处理。
步骤：
1，定义了实现Runnable接口。
2，覆盖接口的run方法。将多线程要运行的代码存入其中。
3，创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
为什么要传递？因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象传递给Thread。让Thread线程去使用该对象调用其run方法。
4，调用Thread对象的start方法。开启线程。
class ThreadDemo implements Runnable//实现Runnable接口
{
publicvoid run(){
//Thread.currentThread() 获取当前线程的对象，相当于this
//Thread类的getName() 获取当前线程的名称
System.out.println(Thread.currentThread().getName()+" Runnablerun...");
}
publicstaticvoid main(String[] args){
ThreadDemo demo=new ThreadDemo();
Thread t1=new Thread(demo);
Thread t2=new Thread(demo);
t1.start(); //开启线程，调用run方法
t2.start();
}
}通过上面的知识点，我们可以知道：
1. 线程都有自己默认的名称，格式是：Thread-编号，该编号是从0开始。
2. 使用多线程的好处是：解决了多部分同时运行的问题。
3. 继承Thred类和实现Runnable接口这两种方式，都能创建线程，但是综合比较，创建线程建议使用实现Runnable接口这种方式，原因如下：
A：通过Thread继承的类,有局限性,不能再继承其他类.，这是java单继承的特性。
B：实现Runnable接口实现多线程,可以实现数据共享，根据接口可以多个实现，并且可以继承其他类，所以功能的扩展性能好。
线程的生命周期
线程可以划分为5个状态：创建、运行、阻塞（临时状态）、冻结、消亡。线程启动后，并不是一直占用cpu独自运行，而是多个线程在cpu中进行切换运行，所以多线程具备随机性。
临时状态的特点：具备了执行资格，但不具备执行权。
冻结状态的特点：放弃了执行资格。
注：启动线程使用的start方法，而不是run方法，调用start方法启动线程，系统会把该run方法当成线程执行体来处理。如果直接调用线程对象的run方法，就相当在执行普通的方法。
多线程运行有什么问题么？
由于多线程的运行具备随机性，就有可能会产生多线程的安全问题。
问题的产生的原因：
几个关键点：
1，多线程代码中有操作共享数据。
2，多条语句操作该共享数据。
当出现上面的情况时，就有可能出现下面问题：
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完，另一个线程开始参与执行。就会发生数据错误。
解决的办法：
当一个线程在执行多条操作共享数据代码时，其他线程即使获取了执行权，也不可以参与操作。
根据上面的思路，那么可以使用Java中提供的同步的原理：就是将部分操作功能数据的代码进行加锁，就可以保证在同一时间只允许一个线程进行操作。
使用同步的前提是：
1，必须是两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。
同步可以分为两种表现形式：
一．同步代码块
synchronized(对象) //该对象可以是任何类的对象.如Object类的对象
{
//...操作共享数据的语句
}函数类型前+synchronized关键字，如下：
publicstaticsynchronizedvoid func(){
//...方法体
}1，同步代码块使用的锁是任意对象。
2，同步函数使用的锁是this。
注意：对于static的同步函数，使用的锁不是this。是 类名.class 是该类的字节码文件对象。
同步的优点和缺点：
优点：解决了线程的安全问题
缺点：要判断同步锁，较为消耗资源；并且同步嵌套后，容易死锁。
死锁：当两个线程相互等待对方释放同步监视器时就会发生死锁。一旦出现死锁，整个程序既不会发生任何异常，也不会给出任何提示，只是所有线程处于阻塞状态，无法继续。
注：同步中可以有多条线程，但是只有一个线程在执行，谁拿锁谁执行
class Ticket implements Runnable
{
private inttick = 100;
Object obj = new Object();
publicvoid run()
{
//show(); //同步方法
while(tick<=100)
{
synchronized(obj) //同步代码块
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
publicsynchronizedvoid show(){//同步方法
for(int i=0;i<100;i++){
System.out.println(Thread.currentThread().getName()+"....同步函数_"+i);
}
}
}
class TicketDemo2
{
publicstaticvoid main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
t1.start();
t2.start();
t3.start();
}
}线程间通讯：其实就是多个线程在操作同一个资源，但是操作的动作不同。
为了让线程协调运行，Object类提供了如下三个方法：
wait()：导致当前线程处于冻结状态，被wait的线程，会被存储到线程池中，可以通过其他线程使用notify()方法或notifyAll()方法来唤醒该线程。
notify()：唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程。
notifAll()：唤醒在此同步监视器上等待的所有线程。只有当前线程放弃对该同步监视器的锁定后，才可能执行被唤醒的线程。
注意：wait()和notify()等待和唤醒的锁,必须是同一个锁。
为什么这些操作线程的方法要定义Object类中呢？
上面的方法只能在持有监视器(锁)的线程中操作，而监视器(锁)可以是任意对象，所以可以被任意对象调用的方法，要定义在Object类中。
其中上面的三个方法都使用在同步中，因为要在持有监视器(锁)的线程操作，但是同步才具有锁，所以只能使用在同步中。
/*
对于多个生产者和消费者。
*/
class Resource{
private String name;
privateintcount = 1;
privatebooleanflag = false;
publicsynchronizedvoid set(String name){
/*为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。*/
while(flag)
try{this.wait();}catch(Exception e){}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
/*为什么定义notifyAll，
因为需要唤醒对方线程。
因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。*/
this.notifyAll();
}
publicsynchronizedvoid out(){
while(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
publicvoid run()
{
while(true)
{
res.set("+商品+");
}
}
}
class Consumer implements Runnable{
private Resource res;
Consumer(Resource res){
this.res = res;
}
publicvoid run(){
while(true){
res.out();
}
}
}
class ProducerConsumerDemo {
publicstaticvoid main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con= new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
t1.start();
t2.start();
}
}其他常用方法：
interrupt()：强制让线程恢复到运行状态中，清除冻结状态。
setDaemon()：当正在运行的线程都是守护线程时，虚拟机退出，如果所有的前台线程都结束，后台线程无论处于何种状态都会自动结束。
join()：哪个线程执行到join方法，哪个线程会释放执行资格，处于冻结状态。
setPriority(级别)：设置线程的优先级，默认优先级是5。其中：线程优先级在1到10之间10个数。优先级越大被执行到的几率越大。
yield()：可以使线程暂时释放执行权。
865
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
