0
点赞
收藏
分享

微信扫一扫

Java高级编程8-姜国海 多线程编程


线程创建 实现runable接口

public class CreateThread  Runable{
public void run(){
}

}

匿名类

没有构造函数
父类的初始化 明确的调用

class A{
int i;
A(int i){
this.i = i;
}
public static void main(){
A a = new A(0);
A b = new A(2){//匿名类没有构造函数,这里的代码充当构造函数的作用
};
K k = new K(){//K是抽象的接口,这里调用的是Object的构造函数的,不是接口的构造函数
}
}
}

//匿名类没有类型,只能用父类的引用调用

new A(0){public void a(){}}.a();

内部类

class A {
class C{//该类的定义依赖于A类的对象
}
想不被依赖
static class C{
}
static abstract 可以同时修饰类,不可以同时修饰函数
void a(){
}
}

一个语法现象

class A {
int i = 0;
class B {
int t;
void a(){
//调用两个i
A.this.i = 9;
B.this.i = 9
}
}
}

sleep函数会抛出检查异常,需要放在try catch 里面

创建线程的方法

继承Thread 重写run方法
Thread t3 = new Thread(){public void run(){}};
实现Runable 接口
Thread t4 = new Thread(new Runable(){public void run(){}});

多线程编程存在临界区问题

两个或多个线程访问全局变量的时候会出现数据的紊乱

解决方案 加锁 (例如:排号机)...这里有故事

synchronized public char pop(){//同步控制
index--;
return data[index];
}


synchronized 可以修饰函数或者代码段
执行同步代码之前必须抢到对象的锁 执行完之后释放锁
将同步的程序 变成串行的 同步的

处于争夺锁的线程,都处于阻塞状态时,虚拟机不保证线程对的强锁顺序,但是一般是先进入阻塞状态的线程优先抢到锁

访问类的成员变量 即全局变量的时候就需要加上同步约束

决绝冲突的办法 一个是加锁 一个是数据复制

public void a(){
synchronized(data){
//这里是同步代码
}
}

划分不同的同步块

class A {
int i,j;
double x,y;
private Object lock1 = new byte[0];
private Object lock2 = new byte[0];

a(){
synchronized(lock1){
x,y;
}

}

b(){
synchronized(lock1){
x,y;
}
}

c(){
synchronized(lock2){
i,j;
}
}
d(){
synchronized(lock2){
i,j;
}
}
}

wait

执行wait操作的线程,释放CPU的执行权,同时释放锁

synchronized public char pop() {
while(index==0){
try{
wait();//释放锁
}catch(e){
e.printStackTrace();
}
}
data[index] = c;
index++;
notify();//唤醒一个处于wait线程,一般是最先阻塞的线程

}

volatile

只能修饰成员变量,保证对这个数据的操作是原子的


举报

相关推荐

0 条评论