一、Java中线程分为两类:
用户线程:平时用到的普通线程均是用户线程
守护线程(后台线程):Java垃圾回收就是一个典型的守护线程。
如果JVM中所有的线程都是守护线程,那么JVM就会退出,进而守护线程也会退出。
如果JVM中还存在用户线程,那么JVM就会一直存活,不会退出。
主线程退出后,守护线程依然在运行!由此得到只要任何非守护线程还在运行,守护线程就不会终止。
一般守护线程是一个死循环,所有的用户线程只要结束,守护线程就结束。
可以用守护线程实现定时器
作用:间隔特定的时间,执行特定的程序。
二、实现线程的第三种方式:
使用Callbable结合Task实现多线程编程。可以获得返回值,前两种没有返回值。
线程的第三种实现方式 FutureTask futureTask = new FutureTask(new Callable())
缺点:在获取线程返回值之前,可以能造成主线程阻塞
package com.jy.Thread;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class ThreadDemo08 {
public static void main(String[] args) {
//创建一个任务类对象futureTask 不是线程对象
FutureTask futureTask = new FutureTask(new Callable() {
@Override
public Object call() throws Exception {
int num = 0;
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+" "+i);
num+=i;
}
return num;
}
});
//创建线程对象
Thread thread = new Thread(futureTask);
thread.setName("t1");
thread.start();
//获取线程的返回值
try {
Object o = futureTask.get();
System.out.println("t1线程的返回值结果为"+o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("主线程结束");
}
}
上述代码中,在获得返回值num后,才会输出“主线程结束”,即主线程被阻塞。
三、Object类中的wait()和notify()方法
在这之前,先了解锁池和等待池的概念:
锁池和等待池
锁池:
假设线程A已经拥有了某个对象(不是类)的锁,而其它线程B,C想要调用这个对象的某个synchronized方法(或者块)之前必须获得该对象锁的拥有权,而恰巧该对象的锁目前正被A所占有,此时B,C线程就会被阻塞,进入一个地方去等待锁的释放,这个地方便是该对象的锁池。
等待池
假设线程A调用了某个对象的wait方法,线程A就会释放该对象的锁,同时线程A就进入到了该对象的等待池中,进入等待池中的线程不会去竞争该对象的锁
wait() 让当前在该对象上活动的线程进入等待状态,无限期的等待,直到被唤醒。wait方法的调用,会让正在该对象的当前线程进入等待状态。
**notify()**方法:会随机选一个处于等待池的线程进入锁池去竞争获取锁的机会。
**notifyAll:**会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会。
生产者与消费者的一个简单案例
生产者:
public class Producer implements Runnable {
private Storehouse storehouse;
public Producer(Storehouse storehouse) {
this.storehouse = storehouse;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
storehouse.in();
}
}
}
消费者:
public class Consumer implements Runnable{
private Storehouse storehouse;
public Consumer(Storehouse storehouse) {
this.storehouse = storehouse;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
storehouse.out();
}
}
}
仓库:
public class Storehouse {
private List list;
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
public Storehouse(List list) {
this.list = list;
}
//生产的方法
public synchronized void in(){
if(this.getList().size() > 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//生产
this.getList().add(new Object());
System.out.println(Thread.currentThread().getName()+"生产了一个产品,对象为"+this.getList().get(0));
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyAll();
}
//消费的方法
public synchronized void out(){
if(this.getList().size() == 0){
try {
//仓库如果是空的,消费者进入等待池等待
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//正常消费
Object remove = this.getList().remove(0);
System.out.println(Thread.currentThread().getName()+"成功消费,消费的商品为"+remove);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
notifyAll();
}
}
测试类:
public class Test {
public static void main(String[] args) {
//共享对象
Storehouse storehouse = new Storehouse(new ArrayList());
//生产者线程对象
Thread t1 = new Thread(new Producer(storehouse));
t1.setName("t1");
//消费者线程对象
Thread t2 = new Thread(new Consumer(storehouse));
t2.setName("t2");
t1.start();
t2.start();
}
}