基础概念
1.程序:程序是为了完成特定任务、用某种语言编写的一组指令的集合。一段静态的代码,静态对象。
2.进程:是程序的一次执行的过程,或是正在运行的一个程序。是一个动态的过程:进程的产生、存在和消亡的过程。——生命周期。
3.线程,进程可以进一步细化为线程,是一个程序内部的一条执行路径。
①若一个进程同一时间并行执行多个线程,那就是支持多线程的
②每个线程拥有独立的运行栈和程序计数器,线程切换的开销小
③一个进程中的多个线程共享相同的内存单元/内存地址空间→它们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。
④一个java应用程序至少有三个线程,主线程,垃圾回收线程,异常处理线程
使用场景
多线程的优点:
1.提高应用程序的响应
2.提高计算机系统CPU使用率
3.改善程序结构
线程的创建方式
1.JDK1.5之前创建新线程有两种方式
①继承Thread类的方式
②实现Runnable接口的方式
创建实现
1.方式一
/**
* 方式一 继承Thread类 重写Thread里面的run方法
*/
class ThreadTest extends Thread {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
//System.out.println(getName()+":"+i);两种写法效果一致
//获取当前线程名并且输出 i
}
}
}
public class MyTest {
public static void main(String[] args) {
ThreadTest test1 = new ThreadTest();
ThreadTest test2 = new ThreadTest();
//创建两个新线程 必须调用start()方法才能开启新线程
test1.start();
// test1.start();同一个实例对象不能调用两次start()方法 会抛出异常IllegalThreadStateException
// test1.run(); 不能直接调用run方法,只是普通的调用类的成员方法不会开启多线程
test2.start();
}
}
那么学习一个类最主要的先要看看它的构造器有哪些:
ok,可以看到它有这么多构造器,先看这几个:
Thread(Runnable) //这个构造器就是方式二创建新线程了,接收一个Runnable接口,该接口里面
//只有一个run()方法
Thread(Runnable,String) //创建新线程并且给线程命名
Thread(String) //创建线程并且命名
①方式一方法练习:
/**
* Thread 类中的常用方法
* 1.start():启动当前线程,调用当前线程的run方法
* 2.run():通常需要重写Thread类中的run()方法,当前方法需要执行的操作写此方法中
* 3.currentThread():静态方法,返回执行当前代码的线程
* 4.getName():获取当前线程的名字
* 5.setName():设置当前线程的名字
* 6.yield():释放当前cpu的执行权
* 7.join():在线程A中调用线程B的join()方法,此时线程A处于阻塞状态,知道线程B结束,线程A才结束阻塞
* 8.stop():强制当前线程死亡,不建议使用 已过时
* 9.sleep(long time):让当前的线程“睡眠”指定毫秒,指定的时间内当前线程是阻塞状态
* 10.isAlive() 判断当前线程是否存活,返回Boolean类型
*/
public class MethodTest {
public static void main(String[] args) throws InterruptedException {
Method1 method1 = new Method1("dd");
method1.start();
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
if (i==20){
method1.join();
}
}
}
}
class Method1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
// try {
// sleep(200);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println(getName()+":"+i);
}
// if (i % 4==0){
// yield();
// }
}
}
public Method1(String name){
super(name);
}
}
②线程的优先级
/**
* 线程的优先级
* 1.
* MAX_PRIORITY:10
* MIN_PRIORITY:1
* NORM_PRIORITY:5 ——>默认的优先级
* 2.如何获取和设置优先级
* getPriority():获取线程的优先级
* setPriority():设置线程的优先级
*说明:高优先级的线程要抢占低优先级线程CPU的执行权。但是只是从概率上讲,优先级高代表的是概率高
* 不是说低优先级一定比低优先级后执行
*/
public class MethodTest {
public static void main(String[] args) throws InterruptedException {
Method1 method1 = new Method1("dd");
// method1.setPriority(Thread.MAX_PRIORITY);
method1.start();
// Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
if (i==20){
method1.join();
}
}
}
}
class Method1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(getName()+":"+i);
}
}
}
public Method1(String name){
super(name);
}
}
③现有100张票需要三个售票点买票,如何设计多线程的方式实现买票呢?(不考虑线程安全问题)
public class Window {
public static void main(String[] args) {
WindowTest window1 = new WindowTest();
WindowTest window2 = new WindowTest();
WindowTest window3 = new WindowTest();
window1.setName("窗口1");
window2.setName("窗口2");
window3.setName("窗口3");
window1.start();
window2.start();
window3.start();
}
}
class WindowTest extends Thread{
private static int ticket = 100; //方式一:使用static 控制同一份买票数量
@Override
public void run() {
while (true){
if (ticket>0){
System.out.println(getName()+":买票,号码:"+ticket);
ticket--;
}else {
break;
}
}
}
}
2.方式二:
/**
* 创建多线程的方式二:实现Runnable接口
* 1.创建一个实现了Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法
* 3.创建实现类的对象
* 4.将此对象作为参数传递到Thread类的构造器中
* 5.调用Thread类中的start()方法
*/
class MThread implements Runnable{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
}
public class Thread2Test {
public static void main(String[] args) {
MThread m = new MThread();
Thread thread = new Thread(m);
thread.start();//此时start() 开启线程后 会调用当前线程的run()方法 此时不是调用MThread()里面重写的run()方法
}
}
①利用方式二实现买票问题
/**
* 不使用static的方式多线程处理同一数据源
*/
class Window2Test implements Runnable{
private int ticket = 100;
@Override
public void run() {
while (true){
if (ticket>0){
System.out.println(Thread.currentThread().getName()+":买票,号:"+ticket);
ticket--;
}else {
break;
}
}
}
}
public class Window2 {
public static void main(String[] args) {
Window2Test window2Test = new Window2Test();
Thread thread1 = new Thread(window2Test);
Thread thread2 = new Thread(window2Test);
Thread thread3 = new Thread(window2Test);
thread1.setName("1");
thread2.setName("2");
thread3.setName("3");
thread1.start();
thread2.start();
thread3.start();
}
}
那么第二种方式创建新线程呢,其实也使用到了多态的特性,Thread构造器接受一个Runnable类型的参数,也就是接收我们Runnable接口的实现类,并且实现了里面的run()方法,如果有多个类实现了该接口,那么最终run()方法就会执行不同的逻辑,也就是有不同的表现新式。同一个接口,使用不同的实例执行不同的操作。
问题
1.继承方式和实现方式有什么区别和联系呢?
答:联系:继承的Thread类 实现了 Runnable接口
区别:继承Thread类:线程代码放在Thread子类中,实现Runnable:线程代码存在在接口子类中
2.实际开发中,是使用继承Thread还是使用实现Runnable接口呢?为什么?
答:
实际开发中,主要使用Runnable接口,
原因:
- 1,实现的方式避免了单继承的局限
- 2,多个线程可以共享同一个接口实现类的对象,非常适合多个相同线程来处理同一份资源。