标签：总结 Thread 对象 void day30 学习 flag 多线程 public
day30_学习总结
多线程实现的两种方式
第一种实现方式:通过继承Thread实现
步骤:
定义继承Thread的子类
重写run()方法
创建线程
启动线程
第二种实现方式:通过实现Runnable接口
步骤:
定义实现Runnable接口的子实现类
重写run()方法
创建资源类对象
创建线程
启动线程
方式二中的线程操作的是同一个资源类,资源类是共享的,更符合多线程的理念
静态代理
通过代理角色来完成真是角色的功能
代理角色
目标角色:真实角色
静态代理的特点:代理角色和目标角色都必须实现同一个接口
eg:多线程通过Runnable接口实现多线程的方式就是静态代理
Thread类为代理角色,实现Runnable接口的子实现类是目标角色
代理角色中要定义实现接口的对象或者真实角色对象
代理角色中需要有有参构造方法,参数为接口或者实现接口的类(真实角色对象)
同步机制—解决多线程安全问题
同步代码块
格式:
synchronized(任意类对象){
对共享数据的操作;
}
同步方法:将对共享数据的操作定义为一个方法,并且方法声明上通过synchronized修饰
权限修饰符 synchronized 返回值类型 方法名(){}
静态同步方法:
权限修饰符 static synchronized 返回值类型 方法名(){}
对于同步方法,其锁对象是this,当前类对象的地址值引用
对于静态同步方法,锁对象是类字节码文件对象,为类名.class
JDK5以后提供接口Lock,也能够实现锁定操作,比synchronized方法更广泛
通过继承Lock接口的子实现类ReentrantLock创建锁对象
void lock()
对象名.lock();//获取锁
void.unlock()
对象名.unlock();//释放锁
注意:
对于Lock这种锁操作,可以配合try...finally...使用,通过finally释放资源
try{
对象名.lock();//获取锁
对共享资源的操作
}finally{
if(对象名!=null){
对象名.unlock();
}
}
判断多线程安全的标准?
1>是否为多线程环境
2>是否存在共享数据
3>是否有多条语句对共享数据进行操作
死锁现象
多个线程操作不同的资源对象,使用同步代码块之后,造成多个线程之间相互等待的现象
生产者消费者模式–等待唤醒机制
生产者:不断生成数据
消费者:不断消耗数据
操作的是同一个资源对象
通过Object类中的wait()方法和notify()方法
例如:以下学生,不断定义对象,不断输出对象
public class Student {
private String name ;
private int age ;
public boolean flag ;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public class SetThread implements Runnable {
private Student s ;
public SetThread(Student s){
this.s = s ;
}
private int x = 0 ;
@Override
public void run() {
while(true){
synchronized (s){
if(s.flag){
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if(x % 2 == 0){
s.setName("路飞");
s.setAge(19);
}else{
s.setName("索隆");
s.setAge(18);
}
s.flag = true ;
s.notify();
}
x++;
}
}
}
public class GetThread implements Runnable{
private Student s ;
public GetThread(Student s){
this.s = s ;
}
@Override
public void run() {
synchronized (s) {
while (true) {
if(!s.flag){
try {
s.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(s.getName() + "---" + s.getAge());
s.flag = false ;
s.notify();
}
}
}
}
public class StudentDemo {
public static void main(String[] args) {
Student s = new Student() ;
SetThread st = new SetThread(s) ;
GetThread gt = new GetThread(s) ;
Thread t1 = new Thread(st) ;
Thread t2 = new Thread(gt) ;
t1.start();
t2.start();
}
}
面试题
wait()和notify()为什么不定义在Thread类中,而定义在Object类中?
wait()和notify()方法都和监视锁有关系,通锁对象有关,而锁对象可以为任意Java类对象,因此,定义在Object类中,任意类对象都可以调用这两个方法
sleep()和wait()方法区别?
不同点:
来源不同:
sleep()定义在Thread类中
wait()定义在Object类中
是否会释放锁:
sleep()方法不会释放锁
wait()方法在调用时会释放锁,然后通过notify()方法唤醒其他线程
相同点:都存在异常,需要对异常进行处理
InterruptedException中断异常
标签：总结,Thread,对象,void,day30,学习,flag,多线程,public 来源： https://blog.csdn.net/p1027544483/article/details/114045361
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。