1.Thread, Runnable, Callable开启线程
- Thread 方法继承Thread,并重写run();
class SomeThead extends Thraad {
public void run() {
//do something here
}
}
public static void main(String[] args){
SomeThread oneThread = new SomeThread();
步骤3:启动线程:
oneThread.start();
}
2.实现Runnable接口创建线程
class SomeRunnable implements Runnable {
public void run() {
//do something here
}
}
Runnable oneRunnable = new SomeRunnable();
Thread oneThread = new Thread(oneRunnable);
oneThread.start();
3.Callable 和 Future 创建线程
public interface Callable {
V call() throws Exception;
}
步骤1:创建实现Callable接口的类SomeCallable(略);
步骤2:创建一个类对象:
Callable oneCallable = new SomeCallable();
步骤3:由Callable创建一个FutureTask对象:
FutureTask oneTask = new FutureTask(oneCallable);
注释: FutureTask是一个包装器,它通过接受Callable来创建,它同时实现了 Future和Runnable接口。
步骤4:由FutureTask创建一个Thread对象:
Thread oneThread = new Thread(oneTask);
步骤5:启动线程:
oneThread.start();
2.线程的生命周期
1.新建状态,就绪状态,运行状态,阻塞状态,死亡状态
2.函数:sleep():当前运行的线程休眠,而不是当前线程休眠
wait():等待
notify():通知一个线程
notifyAll():通知所有线程
yeild():让出进程,重新进入就绪
join():让几个并行的线程组合成串行的线程
setPriority(int newPriority)和getPriority() :设置优先级
3.结束线程:不应该使用stop(),suspend(),resume()等。
正确的方法是使用标识符来结束掉线程
class MyThread extends Thread {
int i=0;
boolean next=true;
@Override
public void run() {
while (next) {
if(i==10)
next=false;
i++;
System.out.println(i);
}
}
}
3.线程同步
1.synchronized关键字
synchronize修饰的方法和 synchronize(this) 都是锁住自己本身的对象 而synchronize(class) synchronize(object) 都是锁别的对象
2.特殊域变量volatile
有锁保护的域和volatile域可以避免非同步的问题。
3.重入锁 ReentrantLock(),lock(),unlock()
class Bank {
private int account = 100;
//需要声明这个锁
private Lock lock = new ReentrantLock();
public int getAccount() {
return account;
}
//这里不再需要synchronized
public void save(int money) {
lock.lock();
try{
account += money;
}finally{
lock.unlock();
}
}
}
4.使用阻塞队列控制线程通信 (BlockingQueue)
4.线程池
1.ExecutorService :Java中对线程池定义的一个接口,最常用的线程池ThreadPoolExecutor
- 调用Executors类的静态工厂方法创建一个ExecutorService对象,该对象代表一个线程池;
- 创建Runnable实现类或Callable实现类的实例,作为线程执行任务;
- 调用ExecutorService对象的submit()方法来提交Runnable实例或Callable实例;
- 当不想提交任务时,调用ExecutorService对象的shutdown()方法来关闭线程池。
2.线程池种类:newFixedThreadPool() ,newCachedThreadPool() ,newSingleThreadExecutor() ,newScheduledThreadPool() ,newSingleThreadScheduledExecutor()
3.ExecutorService 方法函数:
**- execute(Runnable):**方法接收一个Runnable实例
**- submit(Runnable):**返回一个Future对象,通过Future对象,我们可以检查提交的任务是否执行完毕
- Future future = executorService.submit(new Runnable() {
public void run() {
System.out.println("Asynchronous task");
}
});
future.get(); //returns null if the task has finished correctly.
- **submit(Callable):**Callable线程返回future对象
**- invokeAny(…):**接收的是一个Callable的集合,无法保证返回的是哪个任务的执行结果,反正是其中的某一个
ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 2";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 3";
}
});
String result = executorService.invokeAny(callables);
System.out.println("result = " + result);
executorService.shutdown();
**- invokeAll(…):**接收一个Callable集合,但是前者执行之后会返回一个Future的List,其中对应着每个Callable任务执行后的Future对象。
ExecutorService executorService = Executors.newSingleThreadExecutor();
Set<Callable<String>> callables = new HashSet<Callable<String>>();
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 1";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 2";
}
});
callables.add(new Callable<String>() {
public String call() throws Exception {
return "Task 3";
}
});
List<Future<String>> futures = executorService.invokeAll(callables);
for(Future<String> future : futures){
System.out.println("future.get = " + future.get());
}
executorService.shutdown();
4.ExecutorService关闭方法:ExecutorService.shutdown()