线程的创建主要有四种方式,
一种是直接继承Thread实现,
另一种是引用接口Runable。
也可以运用内部类实现接口的创建。但是用这种方法创建的线程只能用一次。以下就是线程的四种创建方式的相关代码:
public class TestThread {
public static void main(String[] args) {
MyThread1 mt = new MyThread1();
MyThread2 mt2 = new MyThread2();
mt.start();
new Thread(mt2).start();
new Thread() {//内部类实现
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("++++线程3++++++" + i);
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("******线程4****" + i);
}
}
}).start();
for (int i = 0; i < 100; i++) {
System.out.println("******主线程****" + i);
}
}
}
/**
*
* 四种方法实现线程的创建,两种运用的是内部类 一种是实现接口,一种是继承线程
*
*/
class MyThread1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("++++线程一++++++" + i);
}
}
}
class MyThread2 implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("-----线程二-------" + i);
}
}
}
当想让线程暂时暂停,进入休眠状态,可以用Sleep实现,该方法是静态方法,可以直接被Thread引用。可以在方法中设置休眠的时间。下面通过一个例子来说明Sleep的用法
import java.io.IOException;
import java.nio.CharBuffer;
public class TestSleep {
public static void main(String[] args) {
Runner r = new Runner();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}
class Runner implements Runnable {
@Override
public void run() {
for (int i = 0; i < 200; i++) {
if (i % 10 == 0 && i != 0) {
try {
Thread.sleep(1000); //Sleep的用法
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("——————————线程————————————" + i);
}
}
}
当想让一个线程先执行完再去执行另一个线程时,可以用Join方法将当前线程先执行完。下面通过一个例子来说明Join的用法。
public class TestJoin {
public static void main(String[] args) {
MyThread2 t1 = new MyThread2("zhangcun");
t1.start();
try {
t1.join();//先执行调用join方法的线程对象的run方法,完成后才调用这条语句所在的线程
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 1; i <= 10; i++) {
System.out.println("------i am main thread");
}
}
}
class MyThread2 extends Thread {
MyThread2(String s) {
super(s);
}
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.println("I am " + getName());
try {
sleep(1000);
} catch (InterruptedException e) {
System.out.println("又被打爆了!");
return;
}
}
}
}
当需要一个线程让出当前执行状态即CPU,给其他线程执行的机会,就需要使用Yield方法,使当前线程暂时阻塞,让程序去执行其他的线程。还是通过一个例子来说明。
public class TestYield {
public static void main(String[] args) {
MyYield my1 = new MyYield();
MyYield2 my2 = new MyYield2();
my1.start();
my2.start();
}
}
class MyYield extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("数字为:" + i);
if (i % 10 == 0 && i != 0) {
yield();
}
}
}
}
class MyYield2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程二数字为:" + i);
if (i % 10 == 0 && i != 0) {
yield();
}
}
}
}
判断当前线程是否还在执行可以使用Thread.currentThread().isAlive()实现。
如果想让某一个线程的优先级优先,可以通过setPriority来设置线程的优先级。当然也会有一个getPriority来获取优先级MinPriority=1,MaxPriority=10,NomPriority=5。下面通过一个例子来说明setPriority的用法。
public class TestPriority {
public static void main(String[] args) {
T1 t = new T1();
T2 tt = new T2();
tt.setPriority(Thread.NORM_PRIORITY + 4);//设置线程的优先级来改变线程的优先级
t.start();
tt.start();
}
}
class T1 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("线程T1" + i);
}
}
}
class T2 extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("--------线程T2" + i);
}
}
}
如果想实现当一个线程在占用一个资源时,不让别的线程来抢占资源,可以使用synchronized来修饰方法或者语句块,这样别的线程就不会进入synchronized修饰的方法或者方法块。
wait()和sleep()的区别:
<1>wait()时别的线程可以访问锁定对象。
<2>调用该方法时必须锁定该对象。
<3>sleep()时别的线程不可以访问锁定对象。
如果两个线程互相占用对方资源,那么线程将会进入死锁状态,在实现线程时,应该尽量避免死锁情况。下面就是一个典型的死锁例子,在编程时,我们应该要避免死锁的发生。
死锁例子:
public class TestDeadLock implements Runnable {
public int flag = 1;
static Object o1 = new Object(), o2 = new Object();
@Override
public void run() {
System.out.println("flag=" + flag);
if (flag == 1) {
synchronized (o1) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (o2) {
System.out.println("1");
}
}
}
if (flag == 0) {
synchronized (o2) {
try {
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
synchronized (o1) {
System.out.println("0");
}
}
}
}
public static void main(String[] args) {
TestDeadLock td1 = new TestDeadLock();
TestDeadLock td2 = new TestDeadLock();
td1.flag = 1;
td2.flag = 0;
Thread t1 = new Thread(td1);
Thread t2 = new Thread(td2);
t1.start();
t2.start();
}
}