黑马程序员5 多线程

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

创建线程的第一种方式：继承Thread类。

步骤：

1，定义类继承Thread。

2，复写Thread类中的run方法。

目的：将自定义代码存储在run方法。让线程运行。

3，调用线程的start方法，

该方法两个作用：启动线程，调用run方法。

创建线程的第二种方式：实现Runable接口

步骤：

1，定义类实现Runnable接口

2，覆盖Runnable接口中的run方法。

将线程要运行的代码存放在该run方法中。

3，通过Thread类建立线程对象。

4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

为什么要将Runnable接口的子类对象传递给Thread的构造函数。

因为，自定义的run方法所属的对象是Runnable接口的子类对象。

所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

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

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

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

两种方式区别：

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

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

范例：

public class Test1 {public static void main(String[] args) {for(int i=0;i<3;i++){new Thread(new Mess()).start();}}
}class Mess implements Runnable{private static int taskcount = 0;private final int id = taskcount ++;Mess(){System.out.println("new message"+id);}@Overridepublic void run() {System.out.println("r1:"+id);Thread.yield();  //对线程调度器的一种建议System.out.println("r2:"+id);Thread.yield();System.out.println("r3:"+id);Thread.yield();System.out.println("end"+id);}
}

=========================================================

Java对于多线程的安全问题提供了专业的解决方式。

就是同步代码块。

synchronized(对象)

{

需要被同步的代码

}

对象如同锁。持有锁的线程可以在同步中执行。

没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

同步规则（何时使用同步）：如果正在写一个变量，他可能接下来被另一个线程读取，或者正在读取一个上一次已经被另一个线程写过的变量，必须使用同步，并且，读写线程都必须用相同的监视器锁同步。

同步函数的锁是this

静态同步函数的锁是Class对象。

 

public class Test1 {public static void main(String[] args) {for(int i=0;i<3;i++){new Thread(new Mess()).start();}}
}class Mess implements Runnable{private static int taskcount = 0;private final int id = taskcount ++;Mess(){System.out.println("new message"+id);}@Overridepublic void run() {System.out.println("r1:"+id);Thread.yield();  //对线程调度器的一种建议System.out.println("r2:"+id);Thread.yield();System.out.println("r3:"+id);Thread.yield();System.out.println("end"+id);}
}

=======================================================

等待/唤醒机制

涉及的方法：

1.wait()：让线程处于冻结状态，被wait的线程会被存储到线程池中。

2.notify()：唤醒线程池中的一个线程（任意）。

3.notifyAll()：唤醒线程池中的所有线程。

这些方法都必须定义在同步中，因为这些方法是用于操作线程状态的方法，

必须要明确到底操作的是哪个锁上的线程。

为什么操作线程的方法 wait、notify、notifyAll定义在了Object类中？

因为这些方法是监视器的方法，监视器其实就是锁。

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

========================================================

Lock接口

将同步和锁封装成了对象，并将操作锁的方式定义到了该对象中，将隐式动作变成了显式动作。

Lock lock=new ReentrantLock();

lock.lock();//获取锁

code...;//throw Exception();

lock.unlock();//释放锁

try

{

lock.lock();//获取锁

}

finally

{

lock.unlock;//释放锁

}

Lock接口：它的出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成了显式锁操作；

同时更为灵活，可以一个锁上加上多组监视器。

lock();获取锁

unlock();释放锁，通常需要定义到finally代码块中。

Condition接口：它的出现替代了Object中的wait、notify、notifyAll方法。

将这些监视器方法单独进行了封装，变成了Condition监视器对象，

可以和任意锁组合。

await();//等待

signal();//唤醒一个等待线程

signalAll();//唤醒所有等待线程

import java.util.concurrent.locks.*;class ProducerConsumerDemo2 
{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();}
}
class Resource
{private String name;private int count = 1;private boolean flag = false;//  t1    t2private Lock lock = new ReentrantLock();private Condition condition_pro = lock.newCondition();private Condition condition_con = lock.newCondition();public  void set(String name)throws InterruptedException{lock.lock();try{while(flag)condition_pro.await();//t1,t2this.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){}}}
}

===============================================================================

interrupt() 将处于强制冻结状态的线程，恢复到运行状态并处理InterruptedException

public class InterruptDemo {public static void main(String[] args) {Thread t = new Thread(new Demo());t.start();System.out.println("Start");t.interrupt();}
}class Demo implements Runnable{private boolean flag  = true;@Overridepublic synchronized void run() {while(flag){try {wait();} catch (InterruptedException e) {System.out.println("interrupted");flag = false;//通过修改标志位，让线程停止
            }}System.out.println("end");}
}

======================================================= 

守护线程： t1.setDaemon(true);

t1.start();

将线程声明为守护线程。（当前台线程停止时，守护线程强行停止）

join:

当A线程执行到了B线程的.join()方法时，A就会等待。等B线程都执行完，A才会执行。

join可以用来临时加入线程执行。

class Demo2 implements Runnable
{public void run(){for(int x=0; x<70; x++){System.out.println(Thread.currentThread().toString()+"....."+x);Thread.yield();}}
}public class JoinDemo
{public static void main(String[] args) throws Exception{Demo2 d = new Demo2();Thread t1 = new Thread(d);t1.start();t1.join();for(int x=0; x<40; x++){System.out.println("main....."+x);}System.out.println("over");}
}

优先级：setPriority(Thread.MAX_PRIORITY);//设置到最高优先级

线程组：每个线程属于其创建者所在的线程组。调用线程的toString方法可以看到其线程组。