知识点
单线程
创建线程类
Java使用 java.lang.Thread 类代表线程,所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是 完成一定的任务,实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。 Java中通过继承Thread类来创建并启动多线程的步骤如下:
- 定义Thread类的子类,并重写该类的run()方法,该run()方法的方法体就代表了线程需要完成的任务,因此把 run()方法称为线程执行体。
- 创建Thread子类的实例,即创建了线程对象
- 调用线程对象的start()方法来启动该线程
代码如下:
测试类:
自定义线程类:
Thread类
构造方法:
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() :返回对当前正在执行的线程对象的引用。
翻阅API后得知创建线程的方式总共有两种,一种是继承Thread类方式,一种是实现Runnable接口方式,接下来讲解方式二实现的方式。
创建线程方式二
采用 java.lang.Runnable 也是非常常见的一种,我们只需要重写run方法即可。
步骤如下:
- 定义Runnable接口的实现类,并重写该接口的run()方法,该run()方法的方法体同样是该线程的线程执行体。
- 创建Runnable实现类的实例,并以此实例作为Thread的target来创建Thread对象,该Thread对象才是真正 的线程对象。
- 调用线程对象的start()方法来启动线程。
通过实现Runnable接口,使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程 代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。
在启动的多线程的时候,需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象,然后调用Thread 对象的start()方法来运行多线程代码。
实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此,不管是继承Thread类还是实现 Runnable接口来实现多线程,最终还是通过Thread的对象的API来控制线程的,熟悉Thread类的API是进行多线程 编程的基础。
tips:
Runnable对象仅仅作为Thread对象的target,Runnable实现类里包含的run()方法仅作为线程执行体。 而实际的线程对象依然是Thread实例,只是该Thread线程负责执行其target的run()方法。
匿名内部类方式实现线程的创建
使用线程的内匿名内部类方式,可以方便的实现每个线程执行不同的线程任务操作。
使用匿名内部类的方式实现Runnable接口,重新Runnable接口中的run方法:
同步代码块
同步代码块: synchronized 关键字可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。
使用同步代码块解决代码:
当使用了同步代码块后,上述的线程的安全问题,解决了。
课堂实践
package Demo01;
// 单线程
public class Demo01MAainThread {
public static void main(String[] args) {
Person p1 = new Person("小强");
p1.run();
//System.out.println(0/0); // 报错就会结束进程
Person p2 = new Person("小刚");
p2.run();
}
}
package Demo01;
/*
*
* java.long.Thread
*
*
*
*/
public class Demo01Thread {
public static void main(String[] args) {
//3.
MyThread mt = new MyThread();
//4.
mt.start();
for(int i=1;i<20;i++) {
System.out.println("主线程:"+i);
//if(i==0)
// System.out.println(0/0);
}
}
}
package Demo01;
// 创建thread子类
public class MyThread extends Thread{
// 重写run方法
@Override
public void run() {
for(int i=1;i<20;i++) {
System.out.println("子线程:"+i);
}
}
}
package Demo01;
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person(String name) {
super();
this.name = name;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
public void run() {
for (int i=1;i<20;i++) {
System.out.println(name+"");
}
}
}
package Demo02;
/*
*
* 多线程
* java.long.Thread
*
* 实现步骤:
* 1、创建一个类的子类
*
* 2、在子类中重写run方法,设置任务(干什么)
* 3、创建子类的对象
* 4、调用类中的方法来启动线程,执行run方法
*/
public class Demo01Thread {
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start(); // 子进程0
new MyThread().start();// 子进程1
new MyThread().start();// 子进程2
new MyThread().start();// 子进程3
System.out.println("main: "+Thread.currentThread().getName());
}
}
package Demo02;
public class Demo02ThreadSetName {
public static void main(String[] args) {
MyTheadName mt = new MyTheadName("小强");
mt.start();
new MyTheadName("旺财").start();
}
}
package Demo02;
public class MyTheadName extends Thread {
public MyTheadName() {
}
public MyTheadName(String name) {
super(name); // 把线程的名称传递给父类,让父类Therad 给子线程起一个名字
}
@Override
public void run() {
//String name = getName();
//System.out.println("run: "+name);
System.out.println("子: "+Thread.currentThread().getName());
}
}
package Demo02;
//1、创建子类
public class MyThread extends Thread {
// 重写run方法
public void run() {
//String name = getName();
//System.out.println("run: "+name);
System.out.println(Thread.currentThread().getName());
}
}
package Demo03;
public class Demo03Sleep {
public static void main(String[] args) {
for(int i=1;i<60;i++) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
package Demo04;
/*
*
* 实现runnable 接口创建
*
*
*
*/
public class Demo04Runnable {
public static void main(String[] args) {
//3、创建一个runnable 接口的实现类对象
RunnableImpl run = new RunnableImpl();
//4、创建类对象,构造方法中传递Runnable 接口实现类对象
//Thread t = new Thread(run);
// 调用thread 类中的start方法,启动子线程
Thread t =new Thread(new RunnableImpl2());
t.start();
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
package Demo04;
//1、创建一个runnable接口实现类
public class RunnableImpl implements Runnable{
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
}
}
package Demo04;
public class RunnableImpl2 implements Runnable{
@Override
public void run() {
for(int i=0;i<20;i++) {
System.out.println("HelloWorld"+"-->"+i);
}
}
}
package Demo05ThradSafe;
public class Demo01Ticket {
public static void main(String[] args) {
RunnableImpl run = new RunnableImpl();
Thread t0 = new Thread(run);
Thread t1 = new Thread(run);
Thread t2 = new Thread(run);
t0.start();
t1.start();
t2.start();
}
}
package Demo05ThradSafe;
/*
* 解决线程安全问题的一种方案:
*
* 使用同步代码块
*
* 格式:synchronized(锁对象){
* 可能会出现线程安全的代码(是因为访问了共享的数据)
*
* }
* 注意:
* 1、通过代码块中的锁对象,可以使用任意对象
* 2、但是必须保证多个线程使用的锁对象是同一个
* 3、锁对象作用:
* 把同步代码块锁住,只让一个线程执行
*
*
*
*/
public class RunnableImpl implements Runnable {
private int ticket =100;
Object obj =new Object();
@Override
public void run() {
while(true) {
synchronized(obj) {
if(ticket>0) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"正在卖第"+ticket+"张票");
ticket--;
}
}
}
}
}
2020080605036