线程创建
Thread类
方式一:继承Thread
- 创建一个继承Thread类的子类
- 重写Thread类的run()
- 创建Thread类的子类对象
- 通过此对象调用start()
//1.创建一个继承Thread类的子类
class MyThread extends Thread{
//2.重写Thread类的run()
@Override
public void run() {
for(int i=0;i<10;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+": " + i +" Mythread");
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3. 创建Thread类的子类对象
MyThread t1 = new MyThread();
// 4.通过此对象调用start()
t1.start();
for(int i=0;i<10;i++){
if(i%2==0){
System.out.println(Thread.currentThread().getName()+": " + i +"-----main");
}
}
}
}
第一次
Thread-0: 0 Mythread
Thread-0: 2 Mythread
main: 0----------------------main
Thread-0: 4 Mythread
Thread-0: 6 Mythread
Thread-0: 8 Mythread
main: 2----------------------main
main: 4----------------------main
main: 6----------------------main
main: 8----------------------main
第二次
main: 0----------------------main
main: 2----------------------main
main: 4----------------------main
main: 6----------------------main
main: 8----------------------main
Thread-0: 0 Mythread
Thread-0: 2 Mythread
Thread-0: 4 Mythread
Thread-0: 6 Mythread
Thread-0: 8 Mythread
调用t.run()方法
main: 0 Mythread
main: 2 Mythread
main: 4 Mythread
main: 6 Mythread
main: 8 Mythread
main: 0----------------------main
main: 2----------------------main
main: 4----------------------main
main: 6----------------------main
main: 8----------------------main
start作用
- 启动当前线程
- 调用当前线程的run()
方式二:创建Thread类的匿名子类的方式
public class ThreadTest {
public static void main(String[] args) {
new Thread(){
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i + " 匿名内部类");
}
}
}
}.start();
}
}
Thread-0: 0 匿名内部类
Thread-0: 2 匿名内部类
Thread-0: 4 匿名内部类
Thread-0: 6 匿名内部类
Thread-0: 8 匿名内部类
Thread类的有关方法
-
void start() 启动线程,并执行对象的run()方法
-
run() 线程在被调度时执行的操作
-
String getName() 返回线程的名称
-
void setName(String name) 设置该线程的名字
-
static Thread currentThread() 返回当前线程,在Thread子类中就是this,通常用于主线程和Runnable实现类
-
static void yield(): 线程同步
- 1暂停当前正在执行的线程,把执行机会给优先级相同或更高的线程
- 2若队列中没有同优先级的线程,忽略此方法
-
join() 当某个程序执行流中调用其他线程的join()方法时,调用线程将被阻塞,直到join()方法加入的join线程执行完成为止
- 1低优先级的线程也可以获得执行
-
static void sleep(long mills) (指定时间:毫秒)
- 1令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重新排队
- 2抛出InterruptedException异常
-
stop() 强制线程生命期结束,不推荐使用
-
boolean isAlive() 返回boolean,判断线程是否还活着
实现Runnable接口(推荐)
- 创建一个实现了Runnbale接口
- 实现类去实现Runnable中的抽象方法:run()
- 创建实现类的对象
- 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
- 通过Thread类的对象去调用start() 方法
// 1.创建一个实现了Runnbale接口
class MyThread implements Runnable {
//2.实现类去实现Runnable中的抽象方法:run()
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
public class ThreadTest {
public static void main(String[] args) {
//3.创建实现类的对象
MyThread myThread = new MyThread();
//4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
Thread t1 = new Thread(myThread);
//5. 通过Thread类的对象去调用start() 方法,启动线程,并执行对象的run()方法--->
// 调用了Runnable类型的target的run()方法
t1.start();
}
}
Thread-0: 0
Thread-0: 2
Thread-0: 4
Thread-0: 6
Thread-0: 8
比较创建线程的两种方式
开发中:优先选择 :实现Runnable接口的方式
原因 :
- 实现的方式没有类的单继承的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况(共享的数据存放在类中static)
联系 : public class Thread implements Runable
相同点: 两种方式都需要重写run(),将线程要执行的逻辑声明在run()中
线程的调度
- 调度策略
- 时间片
- 抢占式
- Java的调度方法
- 同优先级线程组成先进先出队列(先到先服务),使时间片策略
- 对同优先级,使用优先调度的抢占式策略
线程的优先级
- MAX_PRIORITY :10
- MIN_PRIORITY :1
- NORM_PRIORITY :5
涉及的方法
- getProprotu() 返回线程的优先级
- setPriority(int newPriority) :改变线程的优先级
说明
- 线程创建时继承父线程的优先级
- 低优先级的只是获得调度的概率低,并非一定是在高优先级线程之后才调用的
线程的生命周期
JKD中用Thread.State类定义了线程的几种状态
要想实现多线程,必须在主线程中创建新的线程对象,Java语言使用Thread类及其子类的对象来表示线程,在它的一个完整的生命周期中通常要经历如下5中状态
- 新建: 当一个Thread类或其子类的对象被声明并创建,新的线程对象处于新建状态
- 就绪: 处于新建状态的线程被start()后,将进入线程队列等待CPU时间片,此时已具备了运行条件,只是没有分配到CPU资源
- 运行:当就绪的线程被调度并获得CPU资源是,便进入运行状态,run()方法定义了线程的操作和功能
- 阻塞:在某种特殊情况下,被人为的挂起或执行输入输出操作是,让出CPU并临时中止自己的执行,进入阻塞状态
- 死亡:线程完成了它的全部工作后线程被提前强制性的中止或出现异常导致结束
线程的安全问题
在Java中,我们通过使用同步机制,来解决线程的安全问题
方式一: 同步代码块
synchronized(同步监视器){
// 需要被同步的的代码
}
说明:
- 操作共享数据的代码—> 需要被同步的代码
- 共享数据—> 多个线程共同操作的变量
- 同步监视器—> 俗称:锁,任何一个类的对象,都可以充当锁,
要求: 多个线程必须要共用一把锁
方式二: 同步方法
- 同步的方式: 解决了线程的安全问题----好出
操作同步代码时,只能有一个线程参与,其他线程等待,相当于一个单线程的过程,效率低
.
线程的死锁
- 死锁
- 不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁
- 出现现死锁后,不会出现异常,不会出现提示,只是所有的线程都处于阻塞状态,无法继续
- 解决办法
- 专门的算法,原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
public class Temp {
public static void main(String[] args) {
StringBuffer sb1 = new StringBuffer();
StringBuffer sb2 = new StringBuffer();
new Thread() {
@Override
public void run() {
synchronized (sb1) {
sb1.append("a");
sb2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (sb2) {
sb1.append("b");
sb2.append("2");
System.out.println(sb1);
System.out.println(sb2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (sb2) {
sb1.append("c");
sb2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (sb1) {
sb1.append("d");
sb2.append("4");
System.out.println(sb1);
System.out.println(sb2);
}
}
}
}).start();
}
}
public class DeadLock implements Runnable {
A a = new A();
B b = new B();
public void init() {
Thread.currentThread().setName("主线程");
// 调用a对象的foo方法
a.foo(b);
System.out.println("进入了主线程之后");
}
public void run() {
Thread.currentThread().setName("副线程");
//调用a对象的foo方法
b.bar(a);
System.out.println();
}
public static void main(String[] args) {
DeadLock dl = new DeadLock();
new Thread(dl).start();
dl.init();
}
}
class A {
public synchronized void foo(B b) { // 同步监视器: A类的对象:a
System.out.println("当前线程名: " + Thread.currentThread().getName() + " 进入了A实例的foo方法");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName() + " 企图调用B实例的last方法");
b.last();
}
public synchronized void last() {// 同步监视器: A类的对象:a
System.out.println("进入了A类的last方法内部");
}
}
class B {
public synchronized void bar(A a) { // 同步监视器: B类的对象:b
System.out.println("当前线程名: " + Thread.currentThread().getName() + " 进入了B实例的foo方法");
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("当前线程名: " + Thread.currentThread().getName() + " 企图调用A实例的last方法");
a.last();
}
public synchronized void last() {// 同步监视器: B类的对象:b
System.out.println("进入了B类的last方法内部");
}
}
Lock(锁)
- 从JKD1.5开始,Java提供了更强大的线程同步机制- - -通过显示定义的同步锁对象来实现同步,同步锁使用Lock对象充当
- java.util.concurrent.locks.Lodk接口是控制多个线程对共享资源进行访问的工具.锁提供了对共享对象资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应获得Lock对象.
- ReentradntLoack类实现了Lock,它拥有与synchronized相同的并发性和内存语义,在实现线程安全的控制中,比较常用的是ReentrantLock ,可以显示加锁,释放锁
import java.util.concurrent.locks.ReentrantLock;
class Window implements Runnable {
private int ticket = 100;
// 1. 实例化
private ReentrantLock lock = new ReentrantLock();
@Override
public void run() {
while (true) {
try {
// 2. 调用锁定lock()
lock.lock();
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 售票,票号为 " + ticket);
ticket--;
} else {
break;
}
} finally {
//3. 调用解锁的方法
lock.unlock();
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1 ");
t2.setName("窗口2 ");
t3.setName("窗口3 ");
t1.start();
t2.start();
t3.start();
}
}
synchronized 和Lock的区别
- 相同:二者都可以解决线程安全问题
- 不同: synchronized 机制在执行完全相应的同步代码以后,自动的释放同步监视器
Lock 需要手动的启动同步Lock() 结束时unlock()
优先使用顺序
Lock—>同步代码块(已经进入了方法体,分配了相应的资源)->同步方法(在方法体之外)
线程通信
- wait() 一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
- notify():一旦执行此方法,就会唤醒被wait的一个线程,如果有多个线程被wait,就唤醒优先级高的
- notifyAll() 一旦执行此方法就会唤醒所有被wait的线程
- 都必须使用在同步方法块or同步方法中的同步监视器
class Window implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true) {
synchronized (this) {
notify();
if (ticket > 0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 售票,票号为 " + ticket);
ticket--;
try {
// 使得调用wait() 方法的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
break;
}
}
}
}
}
public class LockTest {
public static void main(String[] args) {
Window w = new Window();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);
t1.setName("窗口1 ");
t2.setName("窗口2 ");
t3.setName("窗口3 ");
t1.start();
t2.start();
t3.start();
}
}
sleep() 和wait()的异同
- 相同点:一旦执行此方法,当前线程就进入阻塞状态,并释放同步监视器
- 不同:Thread类中声明sleep(),Object中使用wait()
sleep()可在任何方中调用,wait必须使用在使用在同步方法块or同步方法中的同步监视器
sleep()不会释放锁,wait()会释放锁
JDK5.0 新增线程的创建方式(实现Callable)
-
与使用Runnable相比,Callable功能更强大些
- 相比run()方法,可以有返回值
- 方法可以抛出异常
- 支持泛型的返回值
- 需要借助FutureTask类,比如获取返回结果
- Future接口
- 可以对具体Runnable,Callable任务的执行结果进行取消,查询是否完成,获取结果等
- FutureTask是Future接口的唯一的实现了
- FutureTask同时实现了Runnable,Future接口,它可以作为Runnable被线程执行,又可以作为Futrue得到Callable的返回值
- 实现方式
- 1.创建一个实现Callable的实现类
- 2实现call方法,将此线程需要执行的操作声明在call()中
- 3创建Callalbe接口实现类的对象
- 4将此实现类的对象作为参数传递到FutureTask构造器中,创建FutrueTask的对象
- 5将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start() 方法
- 6获取Callable中call方法的返回值
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyThread {
public static void main(String[] args) {
ThreadNew threadNew = new ThreadNew();
FutureTask futureTask = new FutureTask(threadNew);
new Thread(futureTask).start();
try {
// get() 方法的返回值为 FutrueTask构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和: "+sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class ThreadNew implements Callable {
@Override
public Object call() throws Exception {
int sum = 0;
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
使用线程池
-
背景:经常创建和销毁,使用量特别大的资源,比如并发情况小的线程,对性能影响较大
-
思路: 提前创建好多个线程,放入线程池中,使用时直接获取,使用完之后放入池中,可以避免频繁创建和销毁,实现重复利用,类似公交车
-
好处
- 提到响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
- 便于管理线程
- corePoolSize :核心池的大小
- maxmumPoolSize:最大线程数
- kepAliveTime:线程没有任务是最长保持多长时间后会中止
-
线程池相关API
- JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
- ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行
Runnable
<T> Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行
Callable
void shutdown() ：关闭连接池
- Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运
行命令或者定期地执行。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
public class ThreadPool {
public static void main(String[] args) {
// 1. 提供指定线程数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 2.执行指定的线程操作,需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new MyThread());
// 3.关闭连接池
service.shutdown();
// service.submit();
//设置线程池的属性
ThreadPoolExecutor tpe = (ThreadPoolExecutor) service;
tpe.setCorePoolSize(15);
// tpe.setKeepAliveTime(new Long(10),h);
}
}
class MyThread implements Runnable {
@Override
public void run() {
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
}
}
}
}
83
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
