@liayun
2016-05-28T11:15:37.000000Z
字数 17940
阅读 1533
java基础
进程:是一个正在执行中的程序。
每一个进程执行都有一个执行顺序。该顺序就是一个执行路径或者叫一个控制单元。
Java VM启动时会有一个进程java.exe,该进程中至少有一个线程负责java程序的执行。而且这个线程运行的代码存在main方法中,该线程称之为主线程。
扩展知识:其实更细节说明JVM,JVM不止启动一个线程,还有负责垃圾回收机制的线程。
如何在自定义的代码中,自定义定义一个线程?
答:通过对API的查找,java已经提供了对线程这类事物的描述,即Thread
类。
创建线程的第一种方式:继承Thread
类。
步骤:
Thread
类Thread
类中的run()
。目的:将自定义的代码存储在run()
,让线程运行start()
。该方法有2个作用:启动线程,调用run()
例,
class Demo extends Thread {
public void run() {
for (int x = 0; x < 60; x++) {
System.out.println("demo run---"+x);
}
}
}
class ThreadDemo {
public static void main(String[] args) {
Demo d = new Demo(); // 创建好一个线程
// d.start(); // 开启线程,并执行该线程的run()
d.run(); // 仅仅是对象的调用方法,而线程创建了,并没有被运行
for (int x = 0; x < 60; x++) {
System.out.println("Hello World!---"+x);
}
}
}
发现运行结果每一次都不同。
因为多个线程都在获取CPU的执行权,CPU执行到谁,谁就运行。明确一点,在某一个时刻,只能有一个程序在运行(多核除外)。CPU在做着快速的切换,以达到看上去是同时运行的效果。我们可以形象地把多线程的运行形容为互相抢夺CPU的执行权,这就是多线程的一个特点:随机性。谁抢到谁执行,至于执行多长,CPU说了算。
为什么要覆盖run()呢?
答:Thread
类用于描述线程,该类就定义了一个功能,用于存储线程要运行的代码,该存储功能就是run()
。也就是说Thread
类中的run()
用于存储线程要运行的代码。
练习:创建两个线程,和主线程交替执行。
解:
class Test extends Thread {
Test(String name) {
super(name);
}
public void run() {
for (int x = 0; x < 60; x++) {
System.out.println((Thread.currentThread()==this)+"..."+this.getName()+" run..."+x);
}
}
}
class ThreadTest {
public static void main(String[] args) {
Test t1 = new Test("one---");
Test t2 = new Test("two+++");
t1.start();
t2.start();
for (int x = 0; x < 60; x++) {
System.out.println("main..."+x);
}
}
}
通过上例,可发现原来线程都有自己默认的名称:Thread-编号
,该编号从0开始。
static Thread currentThread()
:获取当前线程对象getName()
:获取线程名称setName()或者构造函数
:设置线程名称以此例引申出创建线程的第二种方式:
例,需求:简单的卖票程序。多个窗口同时买票。
class Ticket implements Runnable {
private int tick = 100;
public void run() {
while(true) {
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);
}
}
}
}
class TicketDemo {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t); // 创建一个线程
Thread t2 = new Thread(t); // 创建一个线程
Thread t3 = new Thread(t); // 创建一个线程
Thread t4 = new Thread(t); // 创建一个线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
创建线程的第二种方式:实现Runnable
接口。
步骤:
Runnable
接口Runnable
接口中的run()
。目的:将线程要运行的代码存放在该run()
中Thread
类建立线程对象Runnable
接口的子类对象作为实际参数传递给Thread
类的构造函数。 Runnable
接口的子类对象作为实际参数传递给Thread
类的构造函数? run()
所属的对象是Runnable
接口的子类对象,所以要让线程去运行指定对象的run()
,就必须明确该run()
所属的对象Thread
类的start()
开启线程并调用Runnable
接口子类的run
方法。实现方式和继承方式有什么区别呢?
1. 实现方式好处:避免了单继承的局限性。在定义线程时,建议使用实现方式
2. 继承Thread
:线程代码存放Thread
子类的run()
中
3. 实现Runnable
:线程代码存放在接口的子类的run()
中
还是以简单的卖票程序为例,通过分析发现打印出0、-1、-2等错票,多线程的运行出现了安全问题。
问题的原因:当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致了共享数据的错误。
解决办法:对多条操作共享数据的语句,只能让一个线程都执行完,在执行过程中,其他线程不可以参与执行。
java对于多线程的安全问题提供了专业的解决方式——就是同步代码块。
注意:线程安全问题在理想状态下,不容易出现,但一旦出现对软件的影响是非常大的。
格式:
synchronized(对象) {
需要被同步的代码
}
对象如同锁,持有锁的线程可以在同步中执行。没有持有锁的线程即使获取CPU的执行权,也进不去,因为没有锁。
火车上的卫生间---经典同步例子。
同步的前提:
必须保证同步中只有一个线程在运行。
同步的好处:解决了多线程的安全问题。
同步的弊端:多个线程需要判断锁,较为消耗资源。
所以同步之后的代码为:
class Ticket implements Runnable {
private int tick = 100;
Object obj = new Object();
public void run() {
while(true) {
synchronized(obj) {
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...sale:"+tick--);
}
}
}
}
}
class TicketDemo2 {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t); // 创建一个线程
Thread t2 = new Thread(t); // 创建一个线程
Thread t3 = new Thread(t); // 创建一个线程
Thread t4 = new Thread(t); // 创建一个线程
t1.start();
t2.start();
t3.start();
t4.start();
}
}
以此例引申出同步函数,需求:银行有一个金库,有两个储户,分别存300元,每次存100元,存3次。目的:该程序是否有安全问题,如果有,如何解决?
class Bank {
private int sum;
public void add(int n) {
sum = sum + n;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
System.out.println("sum="+sum);
}
}
class Cus implements Runnable {
private Bank b = new Bank();
public void run() {
for(int x = 0; x < 3; x++) {
b.add(100);
}
}
}
class BankDemo {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
解:
如何找到问题:
所以,修改之后的代码为:
class Bank {
private int sum;
// Object obj = new Object();
// 同步函数
public synchronized void add(int n) {
// synchronized(obj) {
sum = sum + n;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
System.out.println("sum="+sum);
// }
}
}
class Cus implements Runnable {
private Bank b = new Bank();
public void run() {
for(int x = 0; x < 3; x++) {
b.add(100);
}
}
}
class BankDemo {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
思考:同步函数用的是哪一个锁呢?
结论:函数需要被对象调用,那么函数都有一个所属对象引用,就是this
。所以同步函数使用的锁是this
。
程序验证:通过该程序进行验证同步函数使用的锁是this
。使用两个线程来卖票,一个线程在同步代码块中,一个线程在同步函数中,都在执行买票动作。
class Ticket implements Runnable {
private int tick = 100;
Object obj = new Object();
boolean flag = true;
public void run() {
if(flag) {
while(true) {
synchronized(this) {
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
}
}
}
} else {
while(true)
show();
}
}
public synchronized void show() { // this
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...show...:"+tick--);
}
}
}
class ThisLockDemo {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t); // 创建一个线程
Thread t2 = new Thread(t); // 创建一个线程
t1.start();
// 主线程停10ms,此刻能运行的线程只有t1
try { Thread.sleep(10); } catch(Exception e) {}
t.flag = false;
// 主线程醒了之后,t1和t2线程同时运行
t2.start();
}
}
又思考:如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不再是this
,因为静态方法中也不可以定义this
。静态进内存时,内存中没有本类对象,但是一定有该类对应的字节码文件对象:类名.class
,该对象的类型是Class
。
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。即类名.class
。
程序验证同上:
class Ticket implements Runnable {
private static int tick = 100;
// Object obj = new Object();
boolean flag = true;
public void run() {
if(flag) {
while(true) {
synchronized(Ticket.class) {
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
}
}
}
} else {
while(true)
show();
}
}
public static synchronized void show() {
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...show...:"+tick--);
}
}
}
class StaticMethodDemo {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t); // 创建一个线程
Thread t2 = new Thread(t); // 创建一个线程
t1.start();
// 主线程停10ms,此刻能运行的线程只有t1
try { Thread.sleep(10); } catch(Exception e) {}
t.flag = false;
// 主线程醒了之后,t1和t2线程同时运行
t2.start();
}
}
饿汉式:
class Single {
private static final Single s = new Single();
private Single() {}
public static Single getInstance() {
return s;
}
}
懒汉式:
class Single {
private static Single s = null;
private Single() {}
public static Single getInstance() {
if(s == null) {
synchronized(Single.class) {
if(s == null)
s = new Single();
}
}
return s;
}
}
面试时,可能会问懒汉式与饿汉式有什么不同?
答:懒汉式的特点用于实例的延迟加载。
又问懒汉式的延迟加载有没有问题?
答:有,如果多线程访问时会出现安全问题。
又问怎么解决?
答:可以加同步来解决,用同步代码块和同步函数都行,但是稍微有一些低效,用双重判断的形式能解决这个效率问题。
最后问加同步时,使用的锁是哪一个?
答:该类所属的字节码文件对象。
面试题:请给我写一个延时加载的单例模式示例?
同步中嵌套同步。
例,
class Ticket implements Runnable {
private int tick = 1000;
Object obj = new Object();
boolean flag = true;
public void run() {
if(flag) {
while(true) {
synchronized(obj) {
show();
}
}
} else {
while(true)
show();
}
}
public synchronized void show() {
synchronized(obj) {
if(tick > 0) {
try { Thread.sleep(10); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...code:"+tick--);
}
}
}
}
class DeadLockDemo {
public static void main(String[] args) {
Ticket t = new Ticket();
Thread t1 = new Thread(t); // 创建一个线程
Thread t2 = new Thread(t); // 创建一个线程
t1.start();
// 主线程停10ms,此刻能运行的线程只有t1
try { Thread.sleep(10); } catch(Exception e) {}
t.flag = false;
// 主线程醒了之后,t1和t2线程同时运行
t2.start();
}
}
面试题:写一个死锁程序。
class Test implements Runnable {
private boolean flag;
Test(boolean flag) {
this.flag = flag;
}
public void run() {
if(flag) {
while(true) {
synchronized(MyLock.locka) {
System.out.println("if locka");
synchronized(MyLock.lockb) {
System.out.println("if lockb");
}
}
}
} else {
while(true) {
synchronized(MyLock.lockb) {
System.out.println("else lockb");
synchronized(MyLock.locka) {
System.out.println("else locka");
}
}
}
}
}
}
// 锁
class MyLock {
static Object locka = new Object();
static Object lockb = new Object();
}
class DeadLockTest {
public static void main(String[] args) {
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));
t1.start();
t2.start();
}
}
其实就是多个线程在操作同一个资源,但是操作的动作不同。
notifyAll()
:唤醒线程池中所有等待的线程。
notify()
:唤醒线程池中第一个等待的线程。
wait()
/notify()
/notifyAll()
:都使用在同步中,因为要对持有监视器(锁)的线程操作,所以要使用在同步中,因为只有同步才具有锁。
思考:wait()
,notify()
,notifyAll()
,用来操作线程为什么定义在了Object
类中?
答:
因为这些方法在操作同步中线程时,都必须标识它们所操作线程持有的锁,只有同一个锁上的被等待线程,才可以被同一个锁上的notify
唤醒,不可以对不同锁中的线程进行唤醒。也就是说,等待和唤醒必须是同一个锁。而锁可以是任意对象,所以可以被任意对象调用的方法定义在Object
类中。
例,
class Res {
String name;
String sex;
boolean flag = false;
}
class Input implements Runnable {
private Res r;
// Object obj = new Object();
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持有r锁的线程
if(x == 0) {
r.name = "mike";
r.sex = "man";
} else {
r.name = "丽丽";
r.sex = "女女女女女";
}
x = (x+1)%2;
r.flag = true;
r.notify(); // notify持有r锁的等待线程
}
}
}
}
class Output implements Runnable {
private Res r;
// Object obj = new Object();
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();
}
}
思考:wait()
,sleep()
有什么区别?
答:
wait()
:释放cpu执行权,释放锁。sleep()
:释放cpu执行权,不释放锁。以上代码经过优化后:
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;
// Object obj = new Object();
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();
}
}
为了理解,我画了一个示意图,如下:
线程操作案例——生产者和消费者(单个)
public class ProducerConsumerDemo {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
t1.start();
t2.start();
}
}
class Resource {
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name) {
if(flag) {
try {
this.wait();
} catch (InterruptedException e) {
}
}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
flag = true;
this.notify();
}
public synchronized void out() {
if(!flag) {
try {
wait();
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
flag = false;
notify();
}
}
class Producer implements Runnable {
private Resource res;
Producer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
res.set("+商品+");
}
}
}
class Consumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
res.out();
}
}
}
运行以上代码是只有一个生成者和一个消费者,当有多个生产者和多个消费者时,会产生异常情况:即重复生产或重复消费。
生产者和消费者(多个)
class ProducerConsumerDemo {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
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();
}
}
class Resource {
private String name;
private int count = 1;
private boolean flag = false;
public synchronized void set(String name) {
while(flag)
try { this.wait(); } catch(Exception e) {}
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
flag = true;
this.notifyAll();
}
public synchronized void out() {
while(!flag)
try { this.wait(); } catch(Exception e) {}
System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable {
private Resource res;
Producer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
res.set("+商品+");
}
}
}
class Consumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
res.out();
}
}
}
对于多个生产者和消费者,为什么一定要定义while
判断标记?
原因:让被唤醒的线程再一次判断标记。
为什么定义notifyAll
?
原因:因为需要唤醒对方线程,因为只用notify
,容易出现只唤醒本方线程的情况,导致程序中的所有线程都等待。
JDK1.5
版本中提供了多线程的升级解决方案。
synchronized
替换成了显示的Lock
操作。Object
中的wait
/notify
/notifyAll
替换成Condition
对象。该对象可以通过Lock
锁进行获取。该示例实现了本方只唤醒对方的操作
import java.util.concurrent.locks.*;
class ProducerConsumerDemo2 {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
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();
}
}
class Resource {
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();
// 返回绑定到此Lock实例的新Condition实例,Lock可以支持多个相关的Condition对象
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 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 Resource res;
Producer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
try {
res.set("+商品+");
} catch(InterruptedException e) {
}
}
}
}
class Consumer implements Runnable {
private Resource res;
Consumer(Resource res) {
this.res = res;
}
public void run() {
while(true) {
try {
res.out();
} catch(InterruptedException e) {
}
}
}
}
面试时,可能会问生产者与消费者有什么替代方案呢?
答:JDK1.5
版本提供了显示的锁机制,以及显示的锁对象上的等待唤醒操作机制。同时将等待唤醒进行了封装,封装完,一个锁对应多个Condition
对象,之前一个锁对应一个Condition
对象。
如何停止线程?
stop()
已经过时,只有一种,即run()
结束。
开启多线程运行,运行代码通常都是循环结构。只要控制住循环,就可以让run()
结束,也就是线程结束。
例,
class StopThread implements Runnable {
private boolean flag = true;
public void run() {
while(flag) {
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();
break;
}
System.out.println(Thread.currentThread().getName()+"........."+num);
}
System.out.println("over");
}
}
特殊情况:当线程处于了冻结状态,就不会读取到标记,那么线程就不会结束。即:
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");
}
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();
break;
}
System.out.println(Thread.currentThread().getName()+"........."+num);
}
System.out.println("over");
}
}
当没有指定的方式让冻结的线程恢复到运行状态时,这时需要对冻结进行清除,强制让线程恢复到运行状态中来,这样就可以操作标记让线程结束。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);
}
System.out.println("over");
}
}
setDaemon(boolean)
:将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java虚拟机退出。
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.setDaemon(true);
t2.setDaemon(true);
t1.start();
t2.start();
int num = 0;
while(true) {
if(num++ == 60) {
break;
}
System.out.println(Thread.currentThread().getName()+"........."+num);
}
System.out.println("over");
}
}
join()
:当A线程执行到了B线程的join()时,A就会等待,等B线程都执行完,A才会执行。join可以用来临时加入线程执行。
class Demo implements Runnable {
public void run() {
for (int x = 0; x < 70; x++) {
System.out.println(Thread.currentThread().toString()+"...."+x);
}
}
}
class JoinDemo {
public static void main(String[] args) throws Exception {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
// t1.setPriority(Thread.MAX_PRIORITY); //设置进程优先级,默认为5
t2.start();
t1.join(); // 主线程冻结
for (int x = 0; x < 80; x++) {
System.out.println("main...."+x);
}
System.out.println("over");
}
}
yield()
:将CPU的执行权释放出去,作用:让线程都有平均运行的机会。
class Demo implements Runnable {
public void run() {
for (int x = 0; x < 70; x++) {
System.out.println(Thread.currentThread().toString()+"...."+x);
Thread.yield(); //将CPU的执行权释放出去,作用:让线程都有平均运行的机会
}
}
}
class JoinDemo {
public static void main(String[] args) throws Exception {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
t1.join(); // 主线程冻结
for (int x = 0; x < 80; x++) {
System.out.println("main...."+x);
}
System.out.println("over");
}
}
实际开发时,怎么使用多线程呢?
以下例进行讲解,假设main()里有3段循环代码运行。可用多线程来实现(代码如下):
class ThreadTest1 {
public static void main(String[] args) {
new Thread() {
public void run() {
for(int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}.start();
for(int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName()+"....."+x);
}
Runnable r = new Runnable() {
public void run() {
for(int x = 0; x < 100; x++) {
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
};
new Thread(r).start();
}
}