关于多线程的一些总结

yousking

浏览: 33390 次
性别:
来自: 广州

最近访客更多访客>>

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

J2EE

多线程 thread 华为

为了准备华为时找到的一些关于多线程的例子，再次发表一下：

ava中的线程
Java中实现多线程的类有两种方法
1.扩展java.lang.Thread类，用它覆盖Thread类的run方法。
2.生成实现java.lang.Runnable接口的类并将其它的实例与java.lang.Thread实例相关联

Thread类最重要的方法是run方法。run方法是新线程执行的方法

线程的几个重要的时间段：
·开始线程的初始化
·线程开始执行main（）瞬间
·线程开始执行start（）的瞬间
·start()创建一个新线程并返回main（）的瞬间
·新线程的初始化
·新线程开始执行run（）的瞬间
·每个线程结束的不同瞬间
注意新线程的初始化，它对run（）的执行，和它的结束都与开始线程的执行同时发生。
警告
一个线程调用start()后，在run（）方法退出前并发调用那方法将导致start()掷出一个java.lang.IllegalThreadStateException对象。

线程间发信
Object 类为此提供了三个函数：wait()、notify() 和 notifyAll()
当对一个线程调用 wait() 时，该线程就被有效阻塞，只到另一个线程对同一个对象调用 notify() 或 notifyAll() 为止

notify仅唤醒一个线程并允许它去获得锁，notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁

在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。

wait就是等待这个对象的同步锁,不过调用这个方法必须先获得这个对象的同步锁

notify:唤醒在等待该对象同步锁的线程

首先是生产者和消费者问题

java 代码

class Stor {
String name = "";
boolean full = false;
public synchronized void setProduction(String name) {
while (full) {
try {
this.wait();
} catch (Exception e) {
System.out.println(e.toString());
}
}
full = true;
System.out.println("ddddddddddddddd");
this.notify();
}
public synchronized void getProduction() {
while (!full) {
try {
this.wait();
} catch (Exception e) {
System.out.println(e.toString());
}
}
full = false;
System.out.println("ffffffffffffffffff");
this.notify();
}
}
class Custome extends Thread {
Stor stor;
public Custome(Stor stor) {
this.stor = stor;
}
public void run() {
while (true) {
stor.getProduction();
}
}
}
class Productor extends Thread {
Stor stor;
public Productor(Stor stor) {
this.stor = stor;
}
public void run() {
while (true) {
stor.setProduction("test");
}
}
}
public class Product {
public static void main(String[] arg) {
Stor stor = new Stor();
Custome custome = new Custome(stor);
custome.start();
Productor productor = new Productor(stor);
productor.start();
}
}

一个关于死锁的例子：

java 代码

public class Test {
public static void main(String[] args) {
final Object resource1 = "resource1";
final Object resource2 = "resource2";
// t1 tries to lock resource1 then resource2
Thread t1 = new Thread() {
public void run() {
// Lock resource 1
synchronized (resource1) {
System.out.println("Thread 1: locked resource 1");
try {
Thread.sleep(50);
} catch (InterruptedException e) {
}
synchronized (resource2) {
System.out.println("Thread 1: locked resource 2");
}
}
}
};
// t2 tries to lock resource2 then resource1
Thread t2 = new Thread() {
public void run() {
synchronized (resource2) {
System.out.println("Thread 2: locked resource 2");
try {
Thread.sleep(50);
} catch (InterruptedException e) {
}
synchronized (resource1) {
System.out.println("Thread 2: locked resource 1");
}
}
}
};
// If all goes as planned, deadlock will occur,
// and the program will never exit.
t1.start();
t2.start();
}
}

分享到：

为什么要始终使用PreparedStatement代替St ... | tag标签总结

2007-03-24 11:38
浏览 1058
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论