网上却是有很多的关于这个的答案，但是都长得一样，为了写这篇博客，自己找了几个例子。
JoinThread:
package com.com.aaa.threadJoinDemo;
public class JoinThread extends Thread{
public JoinThread(String name) {
super(name);
}
@Override
public void run() {
for (int i=0;i<100;i++){
System.out.println(this.getName()+"----i"+i);
}
}
}
主函数：
package com.com.aaa.threadJoinDemo;
public class MainJoinThread {
public static void main(String[] args) throws InterruptedException {
JoinThread j1=new JoinThread("小明");
JoinThread j2=new JoinThread("小红");
j1.start();
j2.start();
}
}
想必有经验的都知道，他们每次运行的结果都是不一样的？到底为什么呢？最主要的原因就是县城之间需要竞争CPU，然后调用run方法才能够执行。废话不必多说，进行下边的实验哈。
Thread 类的常用函数及功能:
1.sleep():
使当前的正在执行线程处于停滞状态，sleep()使线程进入堵塞状态，同时不会释放所资源，
sleep可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会
package com.com.aaa.threadJoinDemo;
public class MainJoinThread {
public static void main(String[] args) throws InterruptedException {
JoinThread j1=new JoinThread("小明");
JoinThread j2=new JoinThread("小红");
j1.start();
Thread.sleep(500);
j2.start();
}
}
说明：当j1执行完毕之后，Thread.sleep(500)让线程处于睡眠状态，过了500l之后，线程继续运行
2.wait():
是当前线程处于等待状态，会释放当前的锁资源，使用wait()的时候要处理
直接看代码：
这个是调用wait()方法
package com.com.aaa.threadWaitDemo;
public class ThreadWaitOne extends Thread {
private Object lock;
public ThreadWaitOne(Object lock) {
this.lock = lock;
}
@Override
public void run() {
try {
synchronized (lock){
System.out.println("开始执行哈"+System.currentTimeMillis());
lock.wait();
System.out.println("执行结束"+System.currentTimeMillis());
}
}catch (Exception e){
e.printStackTrace();
}
}
}
唤醒wait()
package com.com.aaa.threadWaitDemo;
public class ThreadWaitTwo extends Thread {
private Object lock;
public ThreadWaitTwo(Object lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock){
System.out.println("开始唤醒"+System.currentTimeMillis());
lock.notify();
System.out.println("开始结束"+System.currentTimeMillis());
}
}
}
主函数
package com.com.aaa.threadWaitDemo;
public class MainThreadWait {
public static void main(String[] args) throws Exception{
Object lock=new Object();
ThreadWaitOne t1=new ThreadWaitOne(lock);
t1.start();
Thread.sleep(5000);
ThreadWaitTwo t2=new ThreadWaitTwo(lock);
t2.start();
}
}
运行结果：
说明：如果t2线程没有将t1线程唤醒，t1会永远处于等待状态
注意：
- wait()、notify()、notifyAll()都必须在synchronized中执行，否则会抛出异常
- wait()、notify()、notifyAll()都是属于超类Object的方法
- 一个对象只有一个锁（对象锁和类锁还是有区别的）
wait()和sleep()区别：
a).wait()可以不指定时间，sleep()必须指定时间
b).wait()不会释放当前锁资源,sleep()能够释放锁资源
).wait()是来自Object类中,sleep()是来自Thread类
3.join():
join()就是让其他线程变为等待(结合例子：知道j1执行完后，才释放)
package com.com.aaa.threadJoinDemo;
public class MainJoinThread {
public static void main(String[] args) throws InterruptedException {
JoinThread j1=new JoinThread("小明");
JoinThread j2=new JoinThread("小红");
j1.start();
j1.join();
j2.start();
}
}
说明：运行结果也不用说了，肯定是小明先执行完毕。
4.stop():
可以停止正在执行得线程，这样的方法不安全，不建议使用。他会解除线程获取的所有锁定，如果线程处于一种不连贯的状态，其他线程有可能在那种状态下检查和修改他们，很难找到问题的所在。
5.suspend():
容易发生死锁，调用suspend()的时候，目标线程会停止，但是却仍然有之前获取的锁定。此时，其他线程都不能有访问线程锁定的资源，除非被"挂起"的线程恢复运行。需要在Thread类中有一个标志
若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。
6.interrupt()
interrupt()不会中断一个正在运行的线程。这一方法实际上完成的是：在线程受到阻塞时抛出一个中断信号，线程就得以退出阻塞的状态。
如果线程被Object.wait，Thread.join，Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（InterruptedException），从而提早地终结被阻塞状态。
如果线程没有被阻塞，这时调用interrupt()将不起作用。
7.yield():
只是使当前线程重新回到可执行状态，所以执行yield()线程有可能在进入到可执行状态后马上又被执行.
只能使同优先级的线程有执行的机会。同样, yield()也不会释放锁资源.
8.setPriority():
线程分配时间片的多少就决定线程使用处理的多少，刚好对应线程优先级别这个概念。可以通过int priority()，里边可以填1-10，默认为5，10最高。
package com.com.aaa.threadJoinDemo;
public class MainJoinThread {
public static void main(String[] args) throws InterruptedException {
JoinThread j1=new JoinThread("小明");
JoinThread j2=new JoinThread("小红");
j2.setPriority(10);
j1.start();
j2.start();
}
}
看下结果，只截图一部分
本来j1先运行的，结果j2运行完之后,j1才运行的，确实说明j2的优先级别要比j1的高
文章来源网络，版权归作者本人所有，如侵犯到原作者权益，请与我们联系删除或授权事宜
如果有误，请联系作者更改，谢谢，本人微信：void666666