下面我们演示一下getName()、setName(String name)、currentThread()、sleep(long time)这些方法的使用效果。
package com.itheima.d2_thread_api;
public class MyThread extends Thread{
public MyThread(String name){
super(name); // 为当前线程设置名字了
}
@Override
public void run() {
// 哪个线程执行它，它就会得到哪个线程对象。
Thread t = Thread.currentThread();
for (int i = 1; i <= 3; i ) {
System.out.println(t.getName() "输出：" i);
}
}
}
package com.itheima.d2_thread_api;
/**
* 目标：掌握Thread的常用方法。
*/
public class ThreadTest1 {
public static void main(String[] args) {
Thread t1 = new MyThread("1号线程");
// t1.setName("1号线程");
t1.start();
System.out.println(t1.getName()); // Thread-0
Thread t2 = new MyThread("2号线程");
// t2.setName("2号线程");
t2.start();
System.out.println(t2.getName()); // Thread-1
// 主线程对象的名字
// 哪个线程执行它，它就会得到哪个线程对象。
Thread m = Thread.currentThread();
m.setName("最牛的线程");
System.out.println(m.getName()); // main
for (int i = 1; i <= 5; i ) {
System.out.println(m.getName() "线程输出：" i);
}
}
}
sleep和join方法的使用
package com.itheima.d2_thread_api;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 目标：掌握sleep方法,join方法的作用。
*/
public class ThreadTest2 {
public static void main(String[] args) throws Exception {
System.out.println(Runtime.getRuntime().availableProcessors());
for (int i = 1; i <= 5; i ) {
System.out.println(i);
// 休眠5s
if(i == 3){
// 会让当前执行的线程暂停5秒，再继续执行
// 项目经理让我加上这行代码，如果用户交钱了，我就注释掉！
Thread.sleep(5000);
}
}
// join方法作用：让当前调用这个方法的线程先执行完。
Thread t1 = new MyThread("1号线程");
t1.start();
t1.join();
Thread t2 = new MyThread("2号线程");
t2.start();
t2.join();
Thread t3 = new MyThread("3号线程");
t3.start();
t3.join();
}
}
执行效果是1号线程先执行完，再执行2号线程；2号线程执行完，再执行3号线程；3号线程执行完就结束了。
线程安全问题
**线程安全问题指的是，多个线程同时操作同一个共享资源的时候，可能会出现业务安全问题。**
为了解决前面的线程安全问题，我们可以使用线程同步思想。同步最常见的方案就是加锁，**意思是每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动释放锁，然后其他线程才能再加锁进来。**
怎么加锁呢？Java提供了三种方案
1.同步代码块
2.同步方法
3.Lock锁
同步代码块
我们先来学习同步代码块。它的作用就是把访问共享数据的代码锁起来，以此保证线程安全。
//锁对象：必须是一个唯一的对象（同一个地址）
synchronized(锁对象){
//...访问共享数据的代码...
}
1.建议把共享资源作为锁对象, 不要将随便无关的对象当做锁对象
2.对于实例方法，建议使用this作为锁对象
3.对于静态方法，建议把类的字节码(类名.class)当做锁对象
package com.itheima.d4_synchronized_code;
public class account {
private String cardId; // 卡号
private double money; // 余额。
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public static void test(){
synchronized (Account.class){
}
}
// 小明 小红线程同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
// this正好代表共享资源！
synchronized (this) {
if(this.money >= money){
System.out.println(name "来取钱" money "成功！");
this.money -= money;
System.out.println(name "来取钱后，余额剩余：" this.money);
}else {
System.out.println(name "来取钱：余额不足~");
}
}
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
package com.itheima.d4_synchronized_code;
public class DrawThread extends Thread{
private Account acc;
public DrawThread(Account acc, String name){
super(name);
this.acc = acc;
}
@Override
public void run() {
// 取钱(小明，小红)
acc.drawMoney(100000);
}
}
package com.itheima.d4_synchronized_code;
/**
* 目标：模拟线程安全问题。
*/
public class ThreadTest {
public static void main(String[] args) {
Account acc = new Account("ICBC-110", 100000);
new DrawThread(acc, "小明").start(); // 小明
new DrawThread(acc, "小红").start(); // 小红
Account acc1 = new Account("ICBC-112", 100000);
new DrawThread(acc1, "小黑").start(); // 小黑
new DrawThread(acc1, "小白").start(); // 小白
}
}
同步方法
**其实同步方法，就是把整个方法给锁住，一个线程调用这个方法，另一个线程调用的时候就执行不了，只有等上一个线程调用结束，下一个线程调用才能继续执行。**
package com.itheima.d5_synchronized_method;
public class Account {
private String cardId; // 卡号
private double money; // 余额。
public Account() {
}
public Account(String cardId, double money) {
this.cardId = cardId;
this.money = money;
}
public static void test(){
synchronized (Account.class){
}
}
// 小明 小红线程同时过来的
// 同步方法
public synchronized void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name "来取钱" money "成功！");
this.money -= money;
System.out.println(name "来取钱后，余额剩余：" this.money);
}else {
System.out.println(name "来取钱：余额不足~");
}
}
public String getCardId() {
return cardId;
}
public void setCardId(String cardId) {
this.cardId = cardId;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
package com.itheima.d5_synchronized_method;
public class DrawThread extends Thread{
private Account acc;
public DrawThread(Account acc, String name){
super(name);
this.acc = acc;
}
@Override
public void run() {
// 取钱(小明，小红)
acc.drawMoney(100000);
}
}
package com.itheima.d5_synchronized_method;
/**
* 目标：模拟线程安全问题。
*/
public class ThreadTest {
public static void main(String[] args) {
Account acc = new Account("ICBC-110", 100000);
new DrawThread(acc, "小明").start(); // 小明
new DrawThread(acc, "小红").start(); // 小红
}
}
同步方法也是有锁对象，只不过这个锁对象没有显示的写出来而已。
1.对于实例方法，锁对象其实是this（也就是方法的调用者）
2.对于静态方法，锁对象时类的字节码对象（类名.class）
最终，总结一下同步代码块和同步方法有什么区别？
1.不存在哪个好与不好，只是一个锁住的范围大，一个范围小
2.同步方法是将方法中所有的代码锁住
3.同步代码块是将方法中的部分代码锁住
Lock锁接下来，我们再来学习一种，线程安全问题的解决办法，叫做Lock锁。
Lock锁是JDK5版本专门提供的一种锁对象，通过这个锁对象的方法来达到加锁，和释放锁的目的，使用起来更加灵活。格式如下
1.首先在成员变量位子，需要创建一个Lock接口的实现类对象（这个对象就是锁对象）
private final Lock lk = new ReentrantLock();
2.在需要上锁的地方加入下面的代码
lk.lock(); // 加锁
//...中间是被锁住的代码...
lk.unlock(); // 解锁
使用Lock锁改写前面DrawThread中取钱的方法，代码如下
// 小明 小红线程同时过来的
public void drawMoney(double money) {
// 先搞清楚是谁来取钱？
String name = Thread.currentThread().getName();
try {
lk.lock(); // 加锁
// 1、判断余额是否足够
if(this.money >= money){
System.out.println(name "来取钱" money "成功！");
this.money -= money;
System.out.println(name "来取钱后，余额剩余：" this.money);
}else {
System.out.println(name "来取钱：余额不足~");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lk.unlock(); // 解锁
}
}线程池概述
线程池就是一个线程复用技术，它可以提高线程的利用率
在JDK5版本中提供了代表线程池的接口ExecutorService，而这个接口下有一个实现类叫ThreadPoolExecutor类，使用ThreadPoolExecutor类就可以用来创建线程池对象。
创建好线程池之后，接下来我们就可以使用线程池执行任务了。线程池执行的任务可以有两种，一种是Runnable任务；一种是callable任务。下面的execute方法可以用来执行Runnable任务。
package com.itheima.d8_thread_pool;
public class MyRunnable implements Runnable{
@Override
public void run() {
// 任务是干啥的？
System.out.println(Thread.currentThread().getName() " ==> 输出666~~");
try {
Thread.sleep(Integer.MAX_VALUE);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package com.itheima.d8_thread_pool;
import java.util.concurrent.*;
/**
* 目标：掌握线程池的创建。
*/
public class ThreadPoolTest1 {
public static void main(String[] args) {
// 1、通过ThreadPoolExecutor创建一个线程池对象。
ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
Runnable target = new MyRunnable();
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target); // 线程池会自动创建一个新线程，自动处理这个任务，自动执行的！
pool.execute(target);
pool.execute(target);
pool.execute(target);
pool.execute(target);
// 到了临时线程的创建时机了
pool.execute(target);
pool.execute(target);
// 到了新任务的拒绝时机了！
pool.execute(target);
// pool.shutdown(); // 等着线程池的任务全部执行完毕后，再关闭线程池
// pool.shutdownNow(); // 立即关闭线程池！不管任务是否执行完毕！
}
}
线程池执行Callable任务
package com.itheima.d8_thread_pool;
import java.util.concurrent.Callable;
/**
* 1、让这个类实现Callable接口
*/
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}
// 2、重写call方法
@Override
public String call() throws Exception {
// 描述线程的任务，返回线程执行返回后的结果。
// 需求：求1-n的和返回。
int sum = 0;
for (int i = 1; i <= n; i ) {
sum = i;
}
return Thread.currentThread().getName() "求出了1-" n "的和是：" sum;
}
}
package com.itheima.d8_thread_pool;
import java.util.concurrent.*;
/**
* 目标：掌握线程池的创建。
*/
public class ThreadPoolTest2 {
public static void main(String[] args) throws Exception {
// 1、通过ThreadPoolExecutor创建一个线程池对象。
ExecutorService pool = new ThreadPoolExecutor(3, 5, 8,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(4), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.CallerRunsPolicy());
// 2、使用线程处理Callable任务。
Future<String> f1 = pool.submit(new MyCallable(100));
Future<String> f2 = pool.submit(new MyCallable(200));
Future<String> f3 = pool.submit(new MyCallable(300));
Future<String> f4 = pool.submit(new MyCallable(400));
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
}
}
接下来，我们学习使用线程池执行Callable任务。callable任务相对于Runnable任务来说，就是多了一个返回值。
执行Callable任务需要用到下面的submit方法
