黑马程序员_多线程1

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

1. 一条线程在同一时刻只能运行一次。

2. 实现方式和继承方式有什么区别呢？

实现方式好处：避免了单继承的局限性。

在定义线程时，建立使用实现方式。

两种方式区别：

继承Thread:线程代码存放Thread子类run方法中。

实现Runnable，线程代码存在接口的子类的run方法。

3. 同步函数锁定的是this，即实现Runnable的类。

4. 静态同步函数锁定的是实现Runnable的类的字节码文件对象，即类名.class。

5. 线程间的通信共享变量的构造：1.共享变量静态修饰。2.单例模式。3.通过构造器传入同一个变量。

6. /*

线程间通讯及等待唤醒机制：

其实就是多个线程在操作同一个资源，

但是操作的动作不同。

*/

class Res

{

String name;

String sex;

boolean flag = false;

}

class Input implements Runnable

{

private Res r ;

Input(Res r)

{

this.r = r;

}

public void run()

{

int x = 0;

while(true)

{

synchronized(r)

{

if(r.flag)

try{r.wait();}catch(Exception e){}

if(x==0)

{

r.name="mike";

r.sex="man";

}

else

{

r.name="丽丽";

r.sex = "女女女女女";

}

x = (x+1)%2;

r.flag = true;

r.notify();

}

}

}

}

class Output implements Runnable

{

private Res r ;

Output(Res r)

{

this.r = r;

}

public void run()

{

while(true)

{

synchronized(r)

{

if(!r.flag)

try{r.wait();}catch(Exception e){}

System.out.println(r.name+"...."+r.sex);

r.flag = false;

r.notify();

}

}

}

}

class  InputOutputDemo

{

public static void main(String[] args) 

{

Res r = new Res();

Input in = new Input(r);

Output out = new Output(r);

Thread t1 = new Thread(in);

Thread t2 = new Thread(out);

t1.start();

t2.start();

}

}

//notifyAll();

/*

wait:

notify();

notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程操作。

所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

*/

代码优化：自己将在Res中定义输入输出函数，并实现线程间的通信机制。

7. 当某个线程处于等待状态被唤醒后，继续执行等待状态后的代码。

8. 生产者消费者模型：

class ProducerConsumerDemo 

{

public static void 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(pro);

Thread t3 = new Thread(con);

Thread t4 = new Thread(con);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

/*

对于多个生产者和消费者。

为什么要定义while判断标记。

原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，

因为需要唤醒对方线程。

因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

*/

class Resource

{

private String name;

private int count = 1;

private boolean flag = false;

//  t1    t2

public synchronized void set(String name)

{

while(flag)

try{this.wait();}catch(Exception e){}

this.name = name+"--"+count++;

System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);

flag = true;

this.notifyAll();

}

public synchronized void 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;

}

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();

}

}

}

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

详细请查看：http://edu.csdn.net/heima