------- android培训、java培训、期待与您交流！ ----------
一、多线程的概念：
进程：电脑中运行的一个程序就是一个进程，如QQ、飞信，迅雷；
线程：一个程序中可能同时运行着多条路线，每条路线都在执行一个功能块，那么这些不同的执行路线就是线程。一个进程实际上是靠线程来完成的。
多线程：系统中可以同时有多条程序在并发的运行，就是多线程。注意一点，对于单核CPU来说，多条线程并不是真正的同时运行的，而是在多个线程间做快速的切换，让外界看起来是同时执行而已。
二、多线程的创建
继承Thread类
1. 子类覆盖父类中的run方法，将运行的代码存放在run方法中
2. 建立子类对象的同时线程也被创建。
3. 通过调用start方法开启线程。
为什么要覆盖run方法呢：
Thread 类用于描述线程。
该类就是定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
也就是说Thread类中的run方法，用于存储线程要运行的代码
比较下面两种方法的区别：
a. start()；开启线程并执行该线程的run方法；
b. d.run（）；仅仅是对象调用方法，而线程创建了并没有运行。
实现Runnable接口：
步骤：
1. 定义类实现Runnable接口
2. 覆盖Runnable接口中的run方法。将线程要运行的代码存放在run方法中。
3. 通过Thread类建立线程对象。
4. 将Runnable接口的子类对象作为实际参数传递给Thread的构造函数。
a) 为什么呢：因为自定义的run方法所属的对象是Runnable接口的子类对象，所以让线程去执行指定对象的run方法，就必须明确该方法所属对象。
b) Thread(Runnabletarget),其实Thread类也是实现了Runnable接口。
调用Thread类的start方法开启线程并调用Runnable接口子类的run方法
三、实现方式和继承方式有什么区别呢？
实现方式的好处：避免了单继承的局限性。
在定义线程时，建议使用实现方式。
两种方式区别：
继承Thread类：线程代码存放Thread子类run方法中。
实现Runnable：线程代码存在接口的子类的run方法中
实际上，Thread也是实现了Runnable接口，从而获得了run方法的。
四、获取线程名称以及对象
原来线程都有自己默认的名称
Thread-编号，该编号从0开始。
Static Thread currentThread():获取当前线程对象。=this.
getName():获取线程名称
设置线程名称：setName()或者构造函数（构造函数中应调用父类的构造函数）
五、多线程的安全问题
多线程的运行会出现安全问题。
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专门的解决方法。就是同步代码块。
Synchronized(对象) {//括号内对象可以使任意对象，一般直接创建个Object对象，省事。
需要啊被同步的代码
}
对象如同锁。持锁的线程可以在同步中执行，没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
其实原理是：当一个线程执行该语句的时候，先判断obj的值，如果是0，则等待；如果是1，则可以进去，并把obj改为0，执行完毕锁内语句后跳出大括号并把锁改为1,其他线程就可以进来了。
锁的好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。
六、线程的同步：
同步的前提：
1. 必须要有两个或两个以上的进程。
2. 必须是多个线程使用同一个锁。
同步有两种表现形式：
同步代码块
同步函数：把同步标识放函数上就可以了。Synchronized void f() {}
必须保证同步中只能有一个线程在运行。
同步函数用的锁是 this。因为函数需要被对象调用，那么函数都有一个所属对象。就是this. 所以同步函数使用的锁是this.
如果同步函数被静态修饰后，使用的锁是什么呢？
不是this,因为静态方法中也不可以定义this.
静态内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。：类名.class 该对象的类型是Class
静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class
七：多线程中的死锁。
在多线程中使用锁时一定要注意死锁的发生。
死锁举例：
lass 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()+"...iflocka ");
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName()+"..iflockb");
}
}
}
}
else
{
while(true)
{
synchronized(MyLock.lockb)
{
System.out.println(Thread.currentThread().getName()+"..elselockb");
synchronized(MyLock.locka)
{
System.out.println(Thread.currentThread().getName()+".....elselocka");
}
}
}
}
}
}
使用sleep（）方法时会抛出interrupt异常。但在run()方法中时不可以抛出异常的（因为其父类run()方法没有抛出异常），必须用try catch捕捉。
将同步代码块变成同步函数，可以将同步代码块单独拉出来写成一个功能函数，再在这个函数前加锁。
通过一个程序进行验证：
使用两个线程来买票，一个线程在同步代码块中，一个线程在同步函数中，都在执行买票动作，有安全隐患。解决方法，就是把同步代码块的锁改写成this. 要用同一个锁。
八、线程间通信——等待唤醒机制
wait();
notify();
notifyAll();
都使用在同步中，是因为你要对持有监视器（锁）的线程操作。
所以要使用在同步中，因为只有同步才具有锁。
为什么这些操作线程的方法要定义在Object类中呢？
因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁，
只有同一个锁上的被等待线程，可以被同一锁上的notify唤醒。不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。而锁可以使任意对象，所以可以被任意对象调用的方法定义Object类中。
九、 线程间通信——生产者消费者问题
当有多个生产者和消费者时，一定要用while循环（判断等待，醒来之后重新判断）和notifyAll
,防止全部等待。（因为 notify唤醒的只是线程池里最先进去的线程）
对于多个生产者和消费者，为什么要定义while判断标记。
原因：让被唤醒的线程再一次判断标记。
为什么定义notifyAll,因为需要唤醒对方线程。若用notify,容易出现只换型本方线程的情况，导致程序中的所有线程都等着。
十、 线程间通信——生产者消费者 JDK5.0升级版
JDK1.5中提供了多线程升级解决方案。将同步Synchronized替换成显示Lock操作。
将Object中的wait，notify、notifyAll,替换成了Condition对象。
该对象可以Lock锁进行获取。
该实例中，实现了本方只唤醒对方操作（双方用不同的锁标记就可以了）
import java.util.concurrent.locks.*;
class ProducerConsumerDemo2
{
public static voidmain(String[] args)
{
Resource r = newResource();
Producer pro = newProducer(r);
Consumer con = newConsumer(r);
Thread t1 = newThread(pro);
Thread t2 = newThread(pro);
Thread t3 = newThread(con);
Thread t4 = newThread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
/*
Lock:替代了Synchronized
lock
unlock
newCondition()
Condition：替代了Object wait notify notifyAll
await();
signal();
signalAll();
*/
class Resource
{
private String name;
private int count = 1;
privateboolean flag = false;
// t1 t2
private Lock lock =new ReentrantLock();
private Conditioncondition_pro = lock.newCondition();
private Conditioncondition_con = lock.newCondition();
public void set(String name)throwsInterruptedException
{
lock.lock();
try
{
while(flag)
condition_pro.await();//t1,t2
this.name =name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
condition_con.signal();
}
finally
{
lock.unlock();//释放锁的动作一定要执行。
}
}
// t3 t4
public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);
flag = false;
condition_pro.signal();
}
finally
{
lock.unlock();
}
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.set("+商品+");
}
catch(InterruptedException e)
{
}
}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)
{
try
{
res.out();
}
catch(InterruptedException e)
{
}
}
}
}
十一、 停止线程
如何停止线程：
1、stop方法，但已经过时。
2、让run方法结束。
开启多线程运行，运行代码通常是循环结构。只要控制住循环，就可以让run方法结束，也就是线程结束。
特殊情况：
当线程处于了冻结状态就不会读取到标记，那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态时，这是需要对冻结进行清除。
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。
Thread类提供该方法 interrupt();
十二、join方法
当A线程执行到了B线程的.join（）方法是，A就会等待。等B线程都执行完，A才会执行。
Join 可以用来临时加入线程执行。
/*
join:
当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。
*/
class Demo implements Runnable
{
public void run()
{
for(int x=0;x<70; x++)
{
System.out.println(Thread.currentThread().toString()+"....."+x);
Thread.yield();
}
}
}
class JoinDemo
{
public static voidmain(String[] args) throws Exception
{
Demo d = newDemo();
Thread t1 = newThread(d);
Thread t2 = newThread(d);
t1.start();
//t1.setPriority(Thread.MAX_PRIORITY);
t2.start();
//t1.join();
for(int x=0;x<80; x++)
{
//System.out.println("main....."+x);
}
System.out.println("over");
}
}
848
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
