Thread类的常用方法----多线程基础练习
创建多线程程序的第一种方式----继承Thread类
常用API
构造方法
public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法
public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
获取线程的名称
继承Thread类重写run方法。
/**
* 获取线程的名称
* 1：使用Thread类中的方法getName()
* String getName() //放回当前线程的名称
* 2：先获得当前执行的线程，使用线程中的getName()方法返回线程的名称
* static Thread currentThread() //返回当前正在执行的线程
*/
public class myThread extends Thread {
@Override
public void run() {
System.out.println(getName());
System.out.println(currentThread().getName());
}
}
主线程
public class Main {
public static void main(String[] args) {
myThread thread = new myThread();
thread.start();
new myThread().start();
new myThread().start();
}
}
效果
设置线程的名称
继承Thread类重写run方法。
/**
* 设置线程的名字
* 1：setName("线程名字")
* 2：使用带参数的构造方法::创建一个带参数的构造方法，参数传递线程的名称；调用父类带参构造方法，让父类（Thread）给子线程起一个名字。
*/
public class myThread extends Thread {
public myThread(){}
public myThread(String name){
super(name);
}
@Override
public void run() {
System.out.println(getName());
}
}
主线程
public class Main {
public static void main(String[] args) {
myThread thread = new myThread();
thread.setName("zhang");
thread.start();
myThread thread2 = new myThread("guang");
thread2.start();
}
}
效果
Sleep方法
继承Thread类重写run方法。
/**
* public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
* 毫秒结束后线程继续执行
*/
public class myThread extends Thread {
@Override
public void run() {
System.out.println("1");
try {
sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(2);
}
}
主线程
public class Main {
public static void main(String[] args) {
myThread thread = new myThread();
thread.start();
System.out.println(".....");
}
}
效果
实现多线程的第二种方式----实现Runnable接口 java.lang.Runnable
介绍
- 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正
的线程对象。 - 调用线程对象的start()方法来启动线程。
通过Runnable接口创建多线程
/**
* 创建多线程的第二种方式，实现Runnable接口
* java.lang.runnable
* Runnable接口应该由那些通过某一线程执行其实例的类来实现。其实例的类必须定义一个称为run的无参数方法
* java.lang.Thread类的构造方法
* Thread(Runnable target) 分配新的 Thread 对象。
* Thread(Runnable target, String name) 分配新的 Thread 对象。
* 实现步骤：
* 1、创建一个Runnable接口的实现类
* 2、在实现类中重写Runnable接口的run方法，设置线程任务
* 3、创建一个Runnable接口的实现类对象
* 4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
* 5、调用Thread类中的start方法，开启新的线程执行run方法
*/
public class myThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
public class Main {
public static void main(String[] args) {
myThread th = new myThread();
Thread thread = new Thread(th);
thread.start();
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
效果
继承Thread和实现Runnable接口的区别
实现Runnable接口比继承Thread类所具有的优势：
- 适合多个相同的程序代码的线程去共享同一个资源。
- 可以避免java中的单继承的局限性。
- 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
- 线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。
匿名内部类实现线程的创建
使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。
/**
* 匿名内部类方式实现线程的创建
*
* 匿名：没有名字
* 内部类：写在其他类内部的类
*
* 匿名内部类作用：简化代码
* 把子类继承父类，重写父类的方法，创建子类对象合一步完成
* 把实现类实现接口，重写接口中的方法，创建实现类兑现合成一步完成
* 匿名内部类的最终产物：子类/实现类对象，而这个类没有名字
*
* 格式
* new 父类/接口（）{
* 重写父类/接口中的方法
* }
*/
public class Main {
public static void main(String[] args) {
//使用Thread类创建
new Thread(){
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}.start();
//使用Runnable接口创建
Runnable r = new Runnable(){
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
};
new Thread(r).start();
//优化Runnable接口方式
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}).start();
//主线程
for (int i = 0; i < 20; i++) {
System.out.println(Thread.currentThread().getName()+i);
}
}
}
效果
线程安全问题
多线程访问了共享数据，会产生线程安全问题
线程不安全案例
/**
* 卖票案例，三个线程同时卖票
*/
public class RunnableImp implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"售出了"+ticket+"号票");
ticket--;
}
}
}
}
public class Main {
public static void main(String[] args) {
RunnableImp runnableImp = new RunnableImp();
new Thread(runnableImp).start();
new Thread(runnableImp).start();
}
}
效果
发现程序出现了两个问题：
- 相同的票数,比如5这张票被卖了两回。
- 不存在的票，比如0票与-1票，是不存在的。
这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。
当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。
要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制
(synchronized)来解决。
java中有三种方式实现同步操作 - 同步代码块。
- 同步方法。
- 锁机制。
第一种解决方式----同步代码块
同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。
格式
synchronized(同步锁){
需要同步操作的代码
}
同步锁:
对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.
- 锁对象 可以是任意类型。
- 多个线程对象 要使用同一把锁。
案例
/**
* 出现了线程安全问题，卖出了重复的和不存在的票
*
* 解决线程安全的一种方式：使用同步代码块
* 格式：
* synchronized（锁对象）{
* 可能会出现线程安全问题的代码
* }
*/
public class RunnableImp implements Runnable {
private int ticket = 100;
//创建一个锁对象，，随便一个对象
Object object = new Object();
@Override
public void run() {
while (true){
//锁对象只有一个，每次运行时一个线程执行会拿走锁对象，其他线程到了，如果没有锁则进入阻塞状态
synchronized (object){
if(ticket>0){
System.out.println(Thread.currentThread().getName()+"售出了"+ticket+"号票");
ticket--;
}
}
}
}
}
public class Main {
public static void main(String[] args) {
RunnableImp runnableImp = new RunnableImp();
new Thread(runnableImp).start();
new Thread(runnableImp).start();
}
}
效果
第二种方式----同步方法
同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外
等着。
格式
public synchronized void method(){
可能会产生线程安全问题的代码
}
/**
* 卖票案例出现了线程安全问题
* 卖出了不存在的票和重复的票
*
* 解决线程安全问题的第二种方案：使用同步方法
* 使用步骤：
* 1、把访问量共享数据的代码抽取出来，放到一个方法中
* 2、在方法上添加synchronized修饰符
*/
public class RunnableImp implements Runnable {
private int ticket = 100;
@Override
public void run() {
while (true){
payTiclet();
}
}
public synchronized void payTiclet(){
if(ticket>0){
try {
//线程休眠，效果更明显
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"售出了"+ticket+"号票");
ticket--;
}
}
}
public class Main {
public static void main(String[] args) {
RunnableImp runnableImp = new RunnableImp();
new Thread(runnableImp).start();
new Thread(runnableImp).start();
new Thread(runnableImp).start();
}
}
效果
同步锁是谁?
对于非static方法,同步锁就是this。
对于static方法,我们使用当前方法所在类的字节码对象(类名.class)。class文件对象
第三种方式----Lock锁
java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,
同步代码块/同步方法具有的功能Lock都有,除此之外更强大,更体现面向对象。
Lock锁也称同步锁，加锁与释放锁方法化了，如下：
public void lock() :加同步锁。
public void unlock() :释放同步锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class RunnableImp implements Runnable {
private int ticket = 100;
Lock lock = new ReentrantLock();
@Override
public void run() {
while (true){
try {
lock.lock();//在可能出现线程安全问题的代码前打开锁
if(ticket>0) {
Thread.sleep(10);
System.out.println(Thread.currentThread().getName() + "售出了" + ticket + "号票");
ticket--;
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();//放在finally中一定会关掉锁
}
}
}
}
public class Main {
public static void main(String[] args) {
RunnableImp runnableImp = new RunnableImp();
new Thread(runnableImp).start();
new Thread(runnableImp).start();
new Thread(runnableImp).start();
}
}
