一、线程间的通讯
线程间通信其实就是多个线程在操作同一个资源，但操作动作不同
一个例子是，生产者消费者：如果有多个生产者和消费者，一定要使用while循环判断标记，然后再使用notifyAll唤醒，否者容易只用notify容易出现只唤醒本方线程情况，导致程序中的所有线程都在等待。
例如：有一个数据存储空间，划分为两个部分，一部分存储人的姓名，一部分存储性别，我们开启一个线程，不停地想其中存储姓名和性别（生产者），开启另一个线程从数据存储空间中取出数据（消费者）。由于是多线程的，就需要考虑，假如生产者刚向数据存储空间中添加了一个人名，还没有来得及添加性别，cpu就切换到了消费者的线程，消费者就会将这个人的姓名和上一个人的性别进行了输出。还有一种情况是生产者生产了若干次数据，消费者才开始取数据，或者消费者取出数据后，没有等到消费者放入新的数据，消费者又重复的取出自己已经去过的数据。
有代码如下：
public class Demo10 {
public static void main(String[] args) {
Person p =new Person();
Producer pro =new Producer(p);
Consumer con = new Consumer(p);
Thread t1 =new Thread(pro,"生产者");
Thread t2 =new Thread(con,"消费者");
t1.start();
t2.start();
}
}
// 使用Person作为数据存储空间
class Person {
Stringname;
Stringgender;
}
// 生产者
class Producerimplements Runnable {
Personp;
public Producer() { }
public Producer(Person p) {
this.p = p;
}
@Override
public void run() {
int i = 0;
while (true) {
if (i % 2 == 0) {
p.name ="jack";
p.gender ="man";
}
else {
p.name ="小丽";
p.gender ="女";
}
i++;
}
}
}
// 消费者
class Consumerimplements Runnable {
Personp;
public Consumer() { }
public Consumer(Person p) {
this.p = p;
}
@Override
public void run() {
while (true) {
System.out.println("name:" +p.name +"---gnder:" +p.gender);
}
}
}
在上述代码中，Producer和Consumer 类的内部都维护了一个Person类型的p成员变量，通过构造函数进行赋值，在main方法中创建了一个Person对象，将其同时传递给Producer和Consumer对象，所以Producer和Consumer访问的是同一个Person对象。并启动了两个线程。输出如下：
屏幕输出了小丽 man 这样的结果是出现了线程安全问题，需要使用synchronized来解决该问题，代码如下：
package cn.itcast.gz.runnable;
public class Demo10 {
public static void main(String[] args) {
Person p =new Person();
Producer pro =new Producer(p);
Consumer con =new Consumer(p);
Thread t1 =new Thread(pro,"生产者");
Thread t2 =new Thread(con,"消费者");
t1.start();
t2.start();
}
}
// 使用Person作为数据存储空间
class Person {
Stringname;
Stringgender;
}
// 生产者
class Producerimplements Runnable {
Personp;
public Producer() { }
public Producer(Person p) {
this.p = p;
}
@Override
public void run() {
int i = 0;
while (true) {
synchronized (p) {
if (i % 2 == 0) {
p.name ="jack";
p.gender ="man";
}
else {
p.name ="小丽";
p.gender ="女";
}
i++;
}
}
}
}
// 消费者
class Consumerimplements Runnable {
Personp;
public Consumer() { }
public Consumer(Person p) {
this.p = p;
}
@Override
public void run() {
while (true) {
synchronized (p) {
System.out.println("name:" +p.name +"---gnder:" +p.gender);
}
}
}
}
此时 编译运行，屏幕没有再输出jack –女 或者小丽- man 这种情况，说明我们解决了线程同步问题。但是仍存在问题：生产者生产了若干次数据，消费者才开始取数据，或者消费者取出数据后，没有等到生产者放入新的数据，消费者又重复的取出自己已经去过的数据。解决方法：在Person类中添加两个方法，set和read方法并设置为synchronized的，让生产者和消费者调用这两个方法，代码如下：
public class Demo10 {
public static voidmain(String[] args) {
Person p =new Person();
Producer pro =new Producer(p);
Consumer con =new Consumer(p);
Thread t1 =new Thread(pro,"生产者");
Thread t2 =new Thread(con,"消费者");
t1.start();
t2.start();
}
}
// 使用Person作为数据存储空间
class Person {
Stringname;
Stringgender;
public synchronized void set(String name, String gender) {
this.name = name;
this.gender = gender;
}
public synchronized void read() {
System.out.println("name:" +this.name +"----gender:" +this.gender);
}
}
// 生产者
class Producerimplements Runnable {
Personp;
public Producer() { }
public Producer(Person p) {
this.p = p;
}
@Override
public void run() {
int i = 0;
while (true) {
if (i % 2 == 0) {
p.set("jack","man");
}
else {
p.set("小丽","女");
}
i++;
}
}
}
// 消费者
class Consumerimplements Runnable {
Personp;
public Consumer() { }
public Consumer(Person p) {
this.p = p;
}
@Override
public void run() {
while (true) {
p.read();
}
}
}
二、等待唤醒机制
wait：告诉当前线程放弃执行权，并放弃监视器（锁）并进入阻塞状态，直到其他线程持有获得执行权，并持有了相同的监视器（锁）并调用notify为止。
notify：唤醒持有同一个监视器（锁）中调用wait的第一个线程，例如，餐馆有空位置后，等候就餐最久的顾客最先入座。注意：被唤醒的线程是进入了可运行状态。等待cpu执行权。
notifyAll：唤醒持有同一监视器中调用wait的所有的线程。
希望实现：生产者生产一次，消费者就消费一次，这样有序的循环。可以通过设置一个标记，表示数据的（存储空间的状态）例如，当消费者读取了（消费了一次）一次数据之后可以将标记改为false，当生产者生产了一个数据，将标记改为true。也就是只有标记为true的时候，消费者才能取走数据，标记为false时候生产者才生产数据。代码实现如下：
package cn.itcast.gz.runnable;
public class Demo10 {
public static voidmain(String[] args) {
Person p =new Person();
Producer pro =new Producer(p);
Consumer con =new Consumer(p);
Thread t1 =new Thread(pro,"生产者");
Thread t2 =new Thread(con,"消费者");
t1.start();
t2.start();
}
}
// 使用Person作为数据存储空间
class Person {
Stringname;
Stringgender;
boolean flag =false;
public synchronized void set(String name, String gender) {
if (!flag) {
try {
wait();
}catch (InterruptedException e) {
e.printStackTrace();
}
}
this.name = name;
this.gender = gender;
flag =true;
notify();
}
public synchronized void read() {
if (flag) {
try {
wait();
}catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("name:" +this.name +"----gender:" +this.gender);
flag =false;
notify();
}
}
// 生产者
class Producerimplements Runnable {
Personp;
public Producer() { }
public Producer(Person p) {
this.p = p;
}
@Override
public void run() {
int i = 0;
while (true) {
if (i % 2 == 0) {
p.set("jack","man");
}else {
p.set("小丽","女");
}
i++;
}
}
}
// 消费者
class Consumerimplements Runnable {
Personp;
public Consumer() { }
public Consumer(Person p) {
this.p = p;
}
@Override
public void run() {
while (true) {
p.read();
}
}
}
线程间通信其实就是多个线程在操作同一个资源，但操作动作不同，wait，notify（），notifyAll()都使用在同步中，因为要对持有监视器（锁）的线程操作，所以要使用在同步中，因为只有同步才具有锁。
为什么这些方法定义在Object类中?
因为这些方法在操作线程时，都必须要标识他们所操作线程持有的锁，只有同一个锁上的被等待线程，可以被统一锁上notify唤醒，不可以对不同锁中的线程进行唤醒，就是等待和唤醒必须是同一个锁。而锁由于可以使任意对象，所以可以被任意对象调用的方法定义在Object类中
wait() 和 sleep()有什么区别？
wait()：释放资源，释放锁，是Object的方法；sleep()：释放资源，不释放锁，是Thread的方法
定义了notify为什么还要定义notifyAll？
因为只用notify容易出现只唤醒本方线程情况，导致程序中的所有线程都在等待。
三、线程的生命周期
任何事物都是生命周期，线程也是，
1. 正常终止 当线程的run()执行完毕，线程死亡。
2. 使用标记停止线程：注意：Stop方法已过时，就不能再使用这个方法。
如何使用标记停止线程：开启多线程运行，运行代码通常是循环结构，只要控制住循环，就可以让run方法结束，线程就结束，代码如下：
class StopThreadimplements Runnable {
public boolean tag =true;
@Override
public void run() {
int i = 0;
while (tag) {
i++;
System.out.println(Thread.currentThread().getName() +"i:" + i);
}
}
}
public class Demo8 {
public static void main(String[] args) {
StopThread st =new StopThread();
Thread th =new Thread(st,"线程1");
th.start();
for (int i = 0; i < 100; i++) {
if (i == 50) {
System.out.println("main i:" + i);
st.tag =false;
}
}
}
}
上述案例中定义了一个计数器i，用来控制main方法（主线程）的循环打印次数，在i到50这段时间内，两个线程交替执行，当计数器变为50，程序将标记改为false，也就是终止了线程1的while循环，run方法结束，线程1也随之结束。注意：当计数器i变为50的，将标记改为false的时候，cpu不一定马上回到线程1，所以线程1并不会马上终止。
四、后台线程
后台线程：就是隐藏起来一直在默默运行的线程，直到进程结束。
实现：setDaemon(boolean on)
特点：当所有的非后台线程结束时，程序也就终止了同时还会杀死进程中的所有后台线程，也就是说，只要有非后台线程还在运行，程序就不会终止，执行main方法的主线程就是一个非后台线程；必须在启动线程之前（调用start方法之前）调用setDaemon（true）方法，才可以把该线程设置为后台线程；一旦main（）执行完毕，那么程序就会终止，JVM也就退出了；可以使用isDaemon()测试该线程是否为后台线程（守护线程）。
案例：开启了一个qq检测升级的后台线程，通过while真循环进行不停检测，当计数器变为100的时候，表示检测完毕，提示是否更新，线程同时结束。为了验证，当非后台线程结束时，后台线程是否终止，故意让该后台线程睡眠一会。发现只要main线程执行完毕，后台线程也就随之消亡了。代码如下：
class QQUpdate implements Runnable {
int i = 0;
@Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() +" 检测是否有可用更新");
i++;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (i == 100) {
System.out.println("有可用更新，是否升级？");
break;
}
}
}
}
public class Demo9 {
public static void main(String[] args) {
QQUpdate qq = new QQUpdate();
Thread th = new Thread(qq,"qqupdate");
th.setDaemon(true);
th.start();
System.out.println(th.isDaemon());
System.out.println("hello world");
}
}
Thread的join方法：当A线程执行到了B线程Join方法时A就会等待，等B线程都执行完A才会执行，Join可以用来临时加入线程执行。
本案例启动了一个JoinThread线程，main（主线程）进行for循环，当计数器为50时，让JoinThread，通过join方法，加入到主线程中，发现只有JoinThread线程执行完，主线程才会执行完毕。可以刻意让JoinThread线程sleep，如果JoinThread没有调用join方法，那么肯定是主线程执行完毕，但是由于JoinThread线程加入到了main线程，必须等JoinThread执行完毕主线程才能继续执行。代码如下：
class JoinThread implements Runnable {
@Override
public void run() {
int i = 0;
while (i < 300) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() +" i:" + i);
i++;
}
}
}
public class Demo10 {
public static void main(String[] args)throws InterruptedException {
JoinThread jt = new JoinThread();
Thread th = new Thread(jt,"one");
th.start();
int i = 0;
while (i < 200) {
if (i == 100) {
th.join();
}
System.err.println(Thread.currentThread().getName() +" i:" + i);
i++;
}
}
}
上述程序用到了Thread类中的join方法，即th.join语句，作用是将th对应的线程合并到调用th.join语句的线程中，main方法的线程中计数器到达100之前，main线程和one线程是交替执行的。在main线程中的计数器到达100后，只有one线程执行，也就是one线程此时被加进了mian线程中，one线程不执行完，main线程会一直等待
带参数的join方法是指定合并时间，有纳秒和毫秒级别。
2761
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
