一,线程的通讯
线程间通信就是多个线程在操作同一个资源,但是操作动作不同。
最经典的例子就是生产者与消费者
//产品类
class Product{
String name; //名字
int price; //价格
boolean flag = false; //产品是否生产完毕的标识
}
//生产者
class Producer extends Thread{
Product p ; //产品
public Producer(Product p) {
this.p = p ;
}
@Override
public void run() {
int i = 0 ;
while(true){
synchronized (p) {
if(p.flag==false){
if(i%2==0){
p.name = "产品1";
p.price = 100;
}else{
p.name="产品2";
p.price = 120;
}
System.out.println("生产者生产出了:"+ p.name+" 价格是:"+ p.price);
p.flag = true;
i++;
}
}
}
}
}
//消费者
class Customer extends Thread{
Product p;
public Customer(Product p) {
this.p = p;
}
@Override
public void run() {
while(true){
synchronized (p) {
if(p.flag==true){ //产品已经生产完毕
System.out.println("消费者消费了"+p.name+" 价格:"+ p.price);
p.flag = false;
}
}
}
}
}
public class Demo4 {
public static void main(String[] args) {
Product p = new Product(); //产品
Producer producer = new Producer(p);//生产者
Customer customer = new Customer(p);//消费者
//调用start方法开启线程
producer.start();
customer.start();
}
}
notify():唤醒线程池等待线程其中的一个。
notify()只是唤醒线程池中已锁对象为标示 等待线程中的一个。而notifyAll()是唤醒全部已锁对象为标示的等待线程
需要注意的是 wait(),notify(),notifyAll()必须要在同步代码块中才能运行 且锁对象必须与调用方法的对象是一个也就是说必须是锁对象调用。
二,线程的停止
public class Demo3 extends Thread {
@Override
public void run() {
System.out.println("自定义线程....");
}
public static void main(String[] args) {
Demo3 d = new Demo3();
d.setPriority(MAX_PRIORITY);
d.start();
for(int i=0; i<=100; i++){
System.out.println("mian线程....");
if(i==80){//当I==80的时候 停止线程
d.stop();
}
}
}
}
方式二:
public class Demo3 extends Thread {
static boolean flag = true;
@Override
public void run() {
while(flag){
System.out.println("自定义线程....");
}
}
public static void main(String[] args) {
Demo3 d = new Demo3();
d.setPriority(MAX_PRIORITY);
d.start();
for(int i=0; i<=100; i++){
System.out.println("mian线程...."+i);
if(i==80){//当I==80的时候 停止线程
flag = false;
}
}
}
}
public class Demo3 extends Thread {
static boolean flag = true;
@Override
public void run() {
while(flag){
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("自定义线程....");
}
}
public static void main(String[] args) {
Demo3 d = new Demo3();
d.setPriority(MAX_PRIORITY);
d.start();
for(int i=0; i<=100; i++){
System.out.println("mian线程...."+i);
if(i==80){//当I==80的时候 停止线程
flag = false;
synchronized (d) {
d.notify();
}
}
}
}
}
当然,不一定要用静态代码块来唤醒线程,还有一种比较粗鲁的方式
public static void main(String[] args) {
Demo3 d = new Demo3();
d.setPriority(MAX_PRIORITY);
d.start();
for(int i=0; i<=100; i++){
System.out.println("mian线程...."+i);
if(i==80){//当I==80的时候 停止线程
flag = false;
d.interrupt();//把线程的等待状态强制清除,但是被清除状态的线程会接收到一个InterruptedException异常
}
}
}
三,后台线程
后台线程:就是隐藏起来一直在默默运行的线程,直到进程结束。
注意:
当所有的非后台线程结束时,程序也就终止了同时还会杀死进程中的所有后台线程,也就是说,只要有非后台线程还在运行,程序就不会终止,main方法的主线程是一个非后台线程。
调用start方法之前,调用setDaemon(true)方法,才可以把该线程设置为后台线程。
使用isDaemon()查看该线程是否为后台线程(守护线程)。
线程默认为非后台线程。
<pre name="code" class="java">public class Demo4 extends Thread{
@Override
public void run() {
int i=0;
while(true){
if(i<100){
System.out.println("已下载了"+i+"%...");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
i++;
}else{
System.out.println("已下载完成,正在准备安装");
break;
}
}
}
public static void main(String[] args) {
Demo4 d = new Demo4();
d.setDaemon(true);//设置线程是否为守护线程,true为守护线程, false为非守护线程。
d.setPriority(MAX_PRIORITY);
System.out.println("是否为后台线程:"+d.isDaemon());
d.start();
for(int i=0; i<100; i++){
System.out.println("主线程...."+ i);
}
}
}
为了验证,当非后台线程结束时,后台线程是否终止,故意让该后台线程睡眠一会。发现只要main线程执行完毕,后台线程也就随之消亡了。
Thread的join方法
当A线程执行到了B线程Join方法时A就会等待,等B线程都执行完A才会执行,Join可以用来临时加入线程执行.
class myThread extends Thread{
@Override
public void run() {
System.out.println("... 4 ...." );
System.out.println("... 5 ...." );
}
}
public class Demo5 {
public static void main(String[] args) {
myThread thread = new myThread();
thread.start();
System.out.println("... 1 ...." );
System.out.println("... 2 ...." );
System.out.println("... 3 ...." );
try {
thread.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("... 6 ...." );
}
}
执行结果:
... 1 ....
... 2 ....
... 3 ....
... 4 ....
... 5 ....
... 6 ....
如果没有加join 执行的结果可能就不是这个顺序了