------- android培训、java培训、期待与您交流! ----------
(day11多线程)**********************************************************************
@@多线程
进程:是一个正在执行中的程序,每一个进程执行都有执行顺序,该顺序是一个执行路径,或者叫控制单元。
线程:就是进程中独立的控制单元,线程在控制着进程的执行。
一个进程中至少有一个线程,
(线程是程序的控制单位或着叫执行路径。)
java jvm 启动时候会有一个进行java.exe
该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在main方法中,该线程称之为主线程。
jvm启动至少有两个线程:一个是主线程,一个是负责垃圾回收机制的线程。
自定义一个线程。
1,继承Thread类,重写run方法。
2,实现Runnable接口,重写run方法。
@@第一种:继承Thread类,重写run方法
1,定义类继承Thread类;class Demo extends Thread
2,重写Thread类中的run方法:将自定义的代码存储在run方法中,让线程运行。
3,调用start() 方法,使该线程开始执行;Java 虚拟机调用该线程的 run 方法。
Demo d = new Demo();
d.start();
多线程的一个特性:随机性,谁抢到cpu,谁就先执行,至于执行多长时间cpu说的算。
为什么覆盖run方法?
Thread类用于描述线程。该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run方法。
也就是说Thread类中的run方法,用于存储程序要运行的代码。
线程运行状态:
<被创建>--start--<运行>--sleep(time)--<冻结>--sleep的time到了--<运行>-
<被创建>--start--<运行>--wait(timeout)--<冻结>--notify--<运行>-
<被创建>--start--<运行>--stop()/或run()结束--<消亡>
<被创建>--start--<临时/阻塞>--<运行>--stop()/或run()结束--<消亡>
被创建:Demo d = new Demo();d.start();
运行:既有执行资格,由有执行权。
临时/阻塞:具备执行资格,但没有执行权,执行权在别的线程手上。
冻结:放弃了执行资格。
消亡:run()执行完,线程结束。
static void sleep(long millis) :等待millis毫秒。
static Thread currentThread() 返回对当前正在执行的线程对象的引用。
String getName() 返回该线程的名称
设置线程名称:构造函数或setName()方法
线程名称:
有自己的默认名称Thread-0...;
也可以初始化时定义名称
class Demo extends Thread
{
Demo(String name)
{
super();
}
public void run
{
for(int x=0;x<100;x++)
{
System.out.println((Thread.currentThread()==this)+":"+this.name+x);
}
}
}
@@第二种:实现Runnable接口,重写run()方法。将实现Runnable接口的类对象传递给Thread类的构造函数。
大多数情况下,如果只想重写 run() 方法,而不重写其他 Thread 方法,那么应使用 Runnable 接口。
这很重要,因为除非程序员打算修改或增强类的基本行为,否则不应为该类创建子类。
1,定义类实现接口Runnable,并重写run方法:class Demo implements Runnable
2,建立Thread对象,并将Runnable的实现类传递给Thread类的构造函数
3,调用Thread类的start方法开启线程。
Demo d = new Demo();
Thread t = new Thread(d);//将d作为实际参数传递给Thread类的构造函数
t.start();//开启线程,并执行d中的run方法。
**实现方式和继承方式的区别?*******
实现方式的好处:避免了单继承的局限性。
继承Thread:线程代码存放在Thread子类的run方法中。
实现Runnable:线程代码存在实现接口的类的run方法中。
在定义线程时,建议最好使用实现接口Runnable的方式。
@@多线程的安全问题
安全问题原因:当多条语句在操作同一个线程共享数据时,一个线程对多条语句值执行了一部分,
还没有执行完,另一个线程就参与进来,导致共享数据的错误。
安全问题的解决办法:对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
java对于多线程的安全问题的解决方式-->同步(同步代码块和同步函数)******
@@同步代码块
class Demo implements Runnable{
private int tick = 1000;//共享数据
Object obj = new Object();//为同步代码块创建一个锁/对象
public void run(){
不需要同步的代码;
synchronized(对象/锁 obj)//同步代码块
{
需要被同步的代码;
try{Thread.sleep(100);}catch{InterruptedException ie}
//不能在函数位置上throws InterruptedException,
//因为实现的接口没有抛出任何异常,所以只能在内部try处理。
}
}
}
同步代码块的原理:
对象存在的时候有个标志位,默认为0;
当Thread-0线程进入同步代码块时,先判断该对象的标志位,
如果为0,表示同步代码快内部没有线程,可以进入,所以Thread-0进入该代码块,同时对象的标志位改为1;
当Thread-1、2、3...等线程想要进入同步代码块时,先判断该对象的标志位,
如果为1,表示同步代码快内部有1个线程,不可以进入,所以Thread-1没有进入该线程,保证了同步代码快内的共享数据的安全性;
当Thread-0线程执行完同步代码块中的语句时,离开代码块,然后同时该对象的标志位变为0,表示同步代码快内没有线程,其他线程可以进入;
同步的前提;***************
1,必须要有两个或者以上的线程。
2,必须是多个线程使用同一个锁()。//不能同步代码快用obj锁,同步函数用this锁。!!!!****
必须保证同步中只有一个线程在运行。
同步的好处:解决了多线程的安全问题。
同步的弊端:多个线程需要判断锁,较为消耗资源。
在程序中查找安全问题:
1,明确哪些代码是多线程运行代码;
2,明确哪些是共享数据;
3,明确多线程代码中哪些语句是操作共享数据的。
同步的表现形式:同步代码块和同步函数
@@同步函数:
public void run()
{
不需要同步的代码;
show();
//如果有同步代码块,切记要和show()函数用同一个锁this,否则不安全!!!!!
//synchronized(this){}
}
public synchronized void show()//默认的锁是this
{
(只是)需要被同步的代码;//只把操作共享数据的语句放这!!
try{Thread.sleep(100);}catch{InterruptedException ie}
//不能在函数位置上throws InterruptedException,
//因为实现的接口没有抛出任何异常,所以只能在内部try处理。
}
@@锁
同步代码块的锁: 同一个对象/锁(可以是this、Demo.class可以是另外的对象)
同步函数的锁:this (调用此同步函数的实例对象)
函数需要被对象调用,函数都有一个所属对象引用,就是this。
静态同步函数的锁:类名.class (静态同步函数所在类 的字节码文件对象)
同步的前提一定要使用同一个锁!!!!
@@死锁: 同步中嵌套同步。两个同步的锁不一样!
写一个死锁程序:
(day12)*******************************************************************
@@wait,notify,notifyAll,用来操作线程为什么定义在了Object类中?
1,这些方法存在于同步中,都用在同步中。因为这些方法要对持有监视器(锁)的线程操作。
2,使用这些方法必须要标识其所属的同步的锁。锁.wait() 锁.notify() 锁.notifyAll().
3,锁可以是任意对象,所以任意对象调用的方法一定定义在Object类中。
等待和唤醒必须是同一把锁。
(wait有异常抛出InterruptedException,notify没有异常抛出)
wait和sleep的区别?//都有InterruptedException异常。
wait:释放资源,释放锁。
sleep:释放资源,不释放锁。
线程间通信:其实就是多个线程操作同一个资源,但是操作的动作不一样。
等待唤醒机制:
例1:单个消费者交替运行,和单个生产者,同步;
class Res //专门用来存放和处理 多线程中的共享数据!
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
if(flag)//set重复执行的时候,flag为真,说明容器有了一个赋值,进入wait,等待输出函数的notify
//out执行完后转过来,flag为假,说明容器中没有赋值,然后跳过wait,进入赋值程序。
try{this.wait();}catch (Exception e){}
this.name = name;
this.sex = sex;
flag = true;//赋值完成后,flag为真,容器中有值,提醒out函数可以进行输出。
this.notify();//唤醒out的notify
}
public synchronized void out()
{
if(!flag)//set执行完后转过来,flag真--容器有值--输出;
//out重复执行的时候,flag为假--容器无值--进入wait,等待set的notify唤醒。
try{this.wait();}catch (Exception e){}
System.out.println(name+"..."+sex);
flag = false;//flag为假,说明容器中没有赋值
this.notify();//唤醒set
}
}
class Input implements Runnable//实现两种赋值方式的交替运行
{
private Res r ;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;//为了让线程t1交替进行赋值。
while(true)//让程序多次运行,更容易看出效果。
{
if(x == 0)//为了让线程t1交替进行赋值。
{
r.set("wzq","nan");
}
else
{
r.set("蛋蛋","女");
}
x = (x+1)%2;//为了让线程t1交替进行赋值。
}
}
}
class Output implements Runnable//实现容器中的值,交替输出。
{
private Res r ;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)//让程序多次运行,更容易看出效果。
{
r.out();
}
}
}
class InputOutputDemo
{
public static void main(String[] args) throws Exception
{
Res r = new Res();
Thread t1 = new Thread(new Input(r));
Thread t2 = new Thread(new Output(r));
t1.start();
t2.start();
}
}
例2:多个生产者和消费者同步进行;
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因:让被唤醒的线程再一次判断标记。
为什么定义notifyAll,
因为需要唤醒对方线程。(不是很优化)
因为只用notify,容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
*/
class Resource
{
private String thing;
private int count = 1;
private boolean flag = false;
public synchronized void set(String thing)
{
while(flag)
try{this.wait();}catch(InterruptedException e){}
this.thing = thing;
this.count = count;
System.out.println(Thread.currentThread().getName()+"生产"+thing+count);
flag = true;
this.notifyAll();
}
public synchronized void out()
{
while(!flag)
try{this.wait();}catch(InterruptedException e){}
System.out.println(Thread.currentThread().getName()+"消费@@@@"+thing+(count++));
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)//让线程多次运行,容易看出结果。
res.set("苹果");
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run()
{
while(true)//让线程多次运行,容易看出结果。
res.out();
}
}
class demo
{
public static void main(String[] s)
{
Resource res = new Resource();
Producer pro = new Producer(res);
Consumer con = new Consumer(res);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(pro);
Thread t3 = new Thread(con);
Thread t4 = new Thread(con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
例3:(JDK1.5后);有一个Object数组,长度100,可以实现多个线程同时进行存储和取出元素。而且数组可以多次使用。
/*
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify notifyAll,替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中,实现了本方只唤醒对方操作。
@@Lock:替代了Synchronized(语句和函数): Lock lock = new ReentrantLock();
lock //获取锁 lock.lock();
unlock//释放锁 lock.unlock;
newCondition()//返回绑定此lock实例的心Condition实例
@@Condition:替代了Object中的wait notify notifyAll; Condition con = lock.newCondition();
await();//等待 con.await();//要抛异常InterruptedException
signal();//唤醒相应的锁 con.signal();
signalAll();//唤醒相应的所有的锁 con.signalAll();
*/
import java.util.concurrent.locks.*;
class BoundedBuffer
{
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int count,putptr,takeptr;
public void put(Object x)throws InterruptedException
{
lock.lock();
try
{
while(count==items.length)
notFull.await();
items[putptr] = x;
System.out.println(Thread.currentThread().getName()+"在向数组中添加第"+putptr+"号角标的元素:"+x);
if(++putptr == items.length)
putptr = 0;
++count;
notEmpty.signal();
}
finally
{
lock.unlock();
}
}
public Object take()throws InterruptedException
{
lock.lock();
try
{
while(count==0)
notEmpty.await();
Object x = items[takeptr];
System.out.println(Thread.currentThread().getName()+"在从数组中取出第"+takeptr+"号角标的元素:"+x);
if(++takeptr == items.length)
takeptr = 0;
--count;
notFull.signal();
return x;
}
finally
{
lock.unlock();
}
}
}
class Put implements Runnable
{
BoundedBuffer bb;
int x = 20;
Put(BoundedBuffer bb)
{
this.bb = bb;
}
public void run()//不能抛,只能在内部进行try
{
while(x-->0)
{
try
{
bb.put(x);
}
catch (InterruptedException e)
{
}
}
}
}
class Take implements Runnable
{
BoundedBuffer bb;
int x = 20;
Take(BoundedBuffer bb)
{
this.bb = bb;
}
public void run()//不能抛,只能在内部进行try
{
while(x-->0)
{
try
{
System.out.println(bb.take());
}
catch (InterruptedException e)
{
}
}
}
}
class demo
{
public static void main(String[] s)
{
BoundedBuffer bb = new BoundedBuffer();
Put p = new Put(bb);
Take t = new Take(bb);
new Thread(p).start();
new Thread(p).start();
new Thread(p).start();
new Thread(p).start();
new Thread(t).start();
new Thread(t).start();
new Thread(t).start();
}
}
@@停止线程:原理:让线程中的run方法可以结束。
1,定义循环结束标记。
特殊情况:
当线程处于了冻结状态。就不会读取到标记,那么线程就不会结束。
2,使用interrupt(中断)方法,(创造一次InterruptedException,然后在catch中进行合理的处理,使线程结束)。
void interrupt()
中断线程。中断 线程的冻结状态 ,然后如果不catch的话线程可能会继续冻结。
如果线程进入了冻结状态,而且也没有别的线程调用notify对其进行唤醒。
那么。可以让线程中断一次,然后再在catch中进行异常处理,将线程结束。
boolean flag = true;
public synchronized void run()
{
while(flag)
{
try
{
wait();//进入冻结状态,而且没有别的线程将其唤醒。
}
catch (InterruptedException e)
{
flag = false;
}
}
}
public static main(String[] s)
{
Thread t1 = new Thread(demo);
t1.start();//进入冻结状态,而且没有别的线程将其唤醒。
t1.interrupt();//创造一次InterruptedException异常,然后线程的run方法中对冻结状态进行处理,让线程正常结束。
}
sleep/wait/join都可以进入冻结状态,都可以用interrupt进行中断。
@@守护线程:(后台线程,用户线程)
setDaemon (boolean on)
public final void setDaemon(boolean on)将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。
该方法必须在启动线程前调用。
t1.setDaemon(true);
t2.setDaemon(true);
t1.start();
t2.start();
当所有的前台线程结束后(main也是前台线程),后台线程自动结束!!!后台依赖前台线程!
一般线程都是前台线程,t.setDaemon(true)才会变为后台程序。
@@t.join:
'谁'碰到了t.join,t就要抢夺'谁'的执行权,然后'谁'被冻结了。
当t运行(期间如果有别的线程也运行,则会和t一起再抢执行权),当t运行完,'谁'才会再继续执行.
当A线程执行到了B线程的.join()方法时,A就会等待。B线程开始执行(期间有别的线程会和B一起再抢执行权),
但是只有当B完全结束后,A才会继续执行。
B.join相当于A和B交换了争夺执行权的资格。等B执行完后,A才有争夺执行权的资格。
join可以用来临时加入线程执行。
@@toString()
返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
哪个线程(如B)开启了该线程A,A就属于B。ThreadGroup(String name)构造一个新线程组。
优先级(1---10,默认为5):优先级越高,执行的机会越多。
setProiority(int x);
Thread.MAX_PRIORITY最高;Thread.MIN_PRIORITY最低优先级;Thread.NORM_PRIORITY默认
getProiority();
@@Thread.yield()
static void yield()
暂停当前正在执行的线程对象,并执行其他线程。
开发中多线程的使用情况:但一段代码需要同时被执行时,(与主函数一起执行,或与其他线程一起执行)
new Thread()//把下面的代码放进一个线程中,与其他线程同步执行。
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}.start();//开启一个线程
for(int x=0; x<100; x++)//主函数中的一个线程
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
Runnable r = new Runnable()//把下面的代码放进一个线程中,与其他线程同步执行。
{
public void run()
{
for(int x=0; x<100; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
};
new Thread(r).start();//开启一个线程