------- android培训、java培训、期待与您交流！ ----------
01 线程间通信-代码示例
02 解决安全问题
/*
需求：解决线程间通信问题
步骤：
1。先建立一个双线程程序
这个双线程操作的是同一个资源但是操作动作不同，也就是需要建立三个类：资源，输入，输出
输入和输出类建立引入一个资源类的对象，而且这个对象是两个类共享的？？
2。线程间安全问题
需要同步的代码块是两个类中都有，一个输入动作，一个输出动作，因此两个类中的run方法都要同步
同步的对象需要唯一，可以考虑class文件，建议Res类的对象，因为这个对象是唯一的而且是两个类共享的
*/
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)
{
}
}
//wait()是obj类中的方法，要抛出异常，只能try不能抛。为了避免同步嵌套，所以前面加对象引用，这个对象是锁
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类中呢？
因为锁是任意对象
等待和唤醒必须是同一把锁
*/
12.04线程间通信-代码优化
同一对象的两个同步方法代码
class Res
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}
catch(Exception e) {}
this.name = name;
this.sex = sex;
flag = true;
this.notify();
}
public synchronized void out()
{
if(!flag)
try{this.wait();}
catch(Exception e) {}
System.out.println(name+"----"+sex);
flag = false;
this.notify();
}
}
class Input implements Runnable
{
private Res r;//??为什么要私有？？
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while (true)
{
if (x == 0)
r.set("mike","man");
else
r.set("莉莉","女");
x= (x+1) % 2;
}
}
}
class Output implements Runnable
{
private Res r;//??为什么要私有？？
Output(Res r)
{
this.r = r;
}
public void run()
{
while (true)
{
r.out();
}
}
}
class InputOutputDemo2
{
public static void main(String[] args)
{
Res r = new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/*Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();*/
}
}
12.05 线程间通信-生产消费者
class Resourse
{
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name)
{
while(flag)
{try
{
wait();
}
catch (Exception e)
{
}
}
this.name = name+"----"+count++;
System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);
flag = true;
notifyAll();
}
public synchronized void out()
{
while(!flag)
{try
{
wait();
}
catch (Exception e)
{
}
}
System.out.println(Thread.currentThread().getName()+"--消费者--"+this.name);
flag = false;
notifyAll();
}
}
class Producer implements Runnable
{
private Resourse r;
Producer(Resourse r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.set("商品");
}
}
}
class Consumer implements Runnable
{
private Resourse r;
Consumer(Resourse r)
{
this.r = r;
}
public void run()
{
while (true)
{
r.out();
}
}
}
class ProducerConsumerDemo
{
public static void main(String[] args)
{
Resourse res = new Resourse();
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();
}
}
/*
对于多个生产者和消费者
为什么要定义while判断标记
原因：
让被唤醒的线程再判断一次标记
为什么要定义notifiAll
因为要唤醒对方线程
如果只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待，
这样会导致程序锁住
*/
12.06 生产者消费者JDK1.5 升级版 lock condition
import java.util.concurrent.locks.*;
class Resourse
{
private String name;
private int count = 1;
private boolean flag = false;
private 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();
this.name = name+"----"+count++;
System.out.println(Thread.currentThread().getName()+"--生产者--"+this.name);
flag = true;
condition_con.signal();
}
finally
{
lock.unlock();
}
}
public synchronized 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 Resourse r;
Producer(Resourse r)
{
this.r = r;
}
public void run()
{
while(true)
{
try
{
r.set("商品");
}
catch (InterruptedException e)
{
}
}
}
}
class Consumer implements Runnable
{
private Resourse r;
Consumer(Resourse r)
{
this.r = r;
}
public void run()
{
while (true)
{
try
{
r.out();
}
catch (InterruptedException e)
{
}
}
}
}
class ProducerConsumerDemo2
{
public static void main(String[] args)
{
Resourse res = new Resourse();
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();
}
}
/*
JDK1.5中提供了多线程升级解决方案
将同步Synchronized替换成实现Lock操作
将Object中的wait，notify，notifyAll替换成了condition
对象，该对象可以对Lock锁进行获取
该示例中，实现了本方只唤醒对方操作
*/
12.07 停止线程
/*
stop方法已经过时
如何停止线程？
只有一种，run方法结束
开启多线程运行，运行代码通常都是循环结构
只要控制住线程，就可以让run方法结束，也就是线程结束
特殊情况：
当线程处于冻结状态，就不糊读取到标记，线程无法结束
当没有指定的方式让冻结的线程恢复到运行状态，这是需要对冻结进行清除
强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束
Thread类中提供了该方法interrupt（）
*/
class StopThread implements Runnable
{
private boolean flag = true;
public synchronized void run()
{
while (flag)
{
try
{
wait();
}
catch (InterruptedException e)
{
System.out.println(Thread.currentThread().getName()+"--Exception");
flag = false;
}
System.out.println(Thread.currentThread().getName()+"--run");
}
}
public void changeFlag()
{
flag = false;
}
}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.start();
t2.start();
int num = 0;
while (true)
{
if (num++ == 60)
{
//st.changeFlag();
t1.interrupt();
t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"----"+num);
}
}
}
/*
setDaemon(true)//相当于前台与后台，守护线程依赖于前台存在，前台退出后台也退出
将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时，Java 虚拟机退出。
该方法必须在启动线程前调用。
该方法首先调用该线程的 checkAccess 方法，且不带任何参数。这可能抛出 SecurityException（在当前线程中）。
参数：
on - 如果为 true，则将该线程标记为守护线程
*/
相关推荐
NULL 博文链接：https://huangminwen.iteye.com/blog/1157983
day05_异常，线程 day06_线程、同步 day07_等待与唤醒案例、线程池、Lambda表达式 day08_File类、递归 day09_字节流、字符流 day10_缓冲流、转换流、序列化流、Files day11_网络编程 day12_函数式接口 day13_Stream...
- 多态性：多态性是指允许不同子类型的对象对同一消息作出不同的响应。 简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。 多态性分为编译时的多态性和运行时的多态性。 总共90多道题目，包含面向...
vc++ 多线程教程---线程通信--利用事件对象,线程同步--使用信号量,线程同步--使用互斥量,线程同步--使用临界区
Java 线程系列博文总结word化，编目如下，欢迎互相学习交流： Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：...
详细的讲述了多线程的各种用法 Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：线程的交互 Java线程：线程的调度-休眠...
黑马程序员_张孝祥_Java多线程与并发库，视频+代码+资料
2.有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 3.异步随机生成各种类型的客户，生成各类型用户的概率比例为： VIP客户：普通客户：快速客户 = 1 ：6 ：3。 4....
计算机专业基础理论电子书合集06----编程语言：java (2) 包括： 深入理解jvm，反射机制，多线程等一些经典图书
NULL 博文链接：https://lvwenwen.iteye.com/blog/1470696
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
面向对象与多线程综合实验做的档案管理系统，包含三类使用人员：系统管理员，档案管理员，普通用户。一共要做七次迭代，每次迭代完成的任务不同。
Java线程：概念与原理 Java线程：创建与启动 Java线程：线程栈模型与线程的变量 Java线程：线程状态的转换 Java线程：线程的同步与锁 Java线程：线程的交互 Java线程：线程的调度-休眠 Java线程：线程的调度-优先级 ...
-多线程：原生支持多线程编程。 3. Java开发环境搭建 -JDK：Java Development Kit，Java开发工具包。 -IDE：集成开发环境，如IntelliJ IDEA或Eclipse。 4. Java基本语法 -数据类型：基本数据类型（int, float, ...
《C++面向对象多线程编程》共分13章，全面讲解构建多线程架构与增量多线程编程技术。第1章介绍了用于构建面向对象程序的不同类型C++组件，以及如何使用这些组件来构建多线程架构。第2、3、4章简要介绍进程、线程、多...
武汉理工大学面向对象与多线程Java综合实验源码 完成时间：2020/11/11 实验目的 运用Java语言，以迭代方式逐步编程实现一个小型档案管理系统。由此了解软件开发的一般过程，深入理解面向对象语言的基本概念和基本...
2004-09-02 16:58 3875 1504 易语言模块大全\BoyChong-神2多方式取IP模块.ec 2005-10-21 23:30 85873 8419 易语言模块大全\BoyChong专用常用模块2.ec 2004-02-07 10:17 4396930 326963 易语言模块大全\Cool皮肤模块....
面向对象的多线程编程，进程必须至少占有一个线程，所以线程是描述进程内的执行，正是线程负责执行包含在进程的地址空间中的代码。