黑马程序员_Java基础(4)--多线程

------- 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();//开启一个线程

------- android培训、java培训、期待与您交流！ ----------