Java基础——多线程(持续更新中)

首先我们先了解一下进程和线程的关系,以及这两者有什么区别。

{

1:要想了解多线程,必须先了解线程,而要想了解线程,必须先了解进程,因为线程是依赖于进程而存在。

2:什么是进程?
    通过任务管理器我们就看到了进程的存在。
    而通过观察,我们发现只有运行的程序才会出现进程。
    进程:就是正在运行的程序。
    进程是系统进行资源分配和调用的独立单位。每一个进程都有它自己的内存空间和系统资源。
    
3:多进程有什么意义呢?
    单进程的计算机只能做一件事情,而我们现在的计算机都可以做多件事情。
    举例:一边玩游戏(游戏进程),一边听音乐(音乐进程)。
    也就是说现在的计算机都是支持多进程的,可以在一个时间段内执行多个任务。
    并且呢,可以提高CPU的使用率。
    
    问题:
        一边玩游戏,一边听音乐是同时进行的吗?
        不是。因为单CPU在某一个时间点上只能做一件事情。
        而我们在玩游戏,或者听音乐的时候,是CPU在做着程序间的高效切换让我们觉得是同时进行的。
        
4:什么是线程呢?
    在同一个进程内又可以执行多个任务,而这每一个任务我就可以看出是一个线程。
    线程:是程序的执行单元,执行路径。是程序使用CPU的最基本单位。
    单线程:如果程序只有一条执行路径。
    多线程:如果程序有多条执行路径。
    
5:多线程有什么意义呢?
    多线程的存在,不是提高程序的执行速度。其实是为了提高应用程序的使用率。
    程序的执行其实都是在抢CPU的资源,CPU的执行权。
    多个进程是在抢这个资源,而其中的某一个进程如果执行路径比较多,就会有更高的几率抢到CPU的执行权。
    我们是不敢保证哪一个线程能够在哪个时刻抢到,所以线程的执行有随机性。

大家注意两个词汇的区别:并行和并发。
 *        前者是逻辑上同时发生,指在某一个时间内同时运行多个程序。
 *        后者是物理上同时发生,指在某一个时间点同时运行多个程序。

* Java程序的运行原理:
 *         由java命令启动JVM,JVM启动就相当于启动了一个进程。
 *         接着有该进程创建了一个主线程去调用main方法。

思考题:
 *         jvm虚拟机的启动是单线程的还是多线程的?
 *             多线程的。
 *             原因是垃圾回收线程也要先启动,否则很容易会出现内存溢出。
 *             现在的垃圾回收线程加上前面的主线程,最低启动了两个线程,所以,jvm的启动其实是多线程的。

}

如何建立一个执行路径呢?

通过查询API文档 java.lang.Thread类

该类的描述中有创建线程的两种方式

1.继承Thread类

(1).将类声明为 Thread 的子类

(2).该子类应重写 Thread 类的 run 方法

(3).创建子类对象就是创建线程对象

(4).调用Thread类中的start方法就可以执行线程,炳辉调用run()方法

Eg:计算大于某一规定值的质数的线程可以写成:

 class PrimeThread extends Thread {
long minPrime;
PrimeThread(long minPrime) {
this.minPrime = minPrime;
} public void run() {
// compute primes larger than minPrime
. . .
}
}

然后,通过下列代码会创建并启动一个线程:

 PrimeThread p = new PrimeThread(143);
p.start();

start()开启线程后,都会执行run()方法.说明run()方法中存储的是线程要运行的代码;所以,记住自定义线程的任务代码都存储在run()方法中

2.声明实现 Runnable 接口

(1).定义一个类,实现runnable

(2).覆盖runnable接口中的run方法,先线程要运行的任务代码存储到该方法中

(3).描述Thread类创建线程对象,并将实现了Runnable接口的对象作为Thread类的构造函数的参数进行传递

(4).调用Thread类的start方法,开启线程

   class PrimeRun implements Runnable {
long minPrime;
PrimeRun(long minPrime) {
this.minPrime = minPrime;
} public void run() {
// compute primes larger than minPrime
. . .
}
}

 然后,下列代码会创建并启动一个线程:

 PrimeRun p = new PrimeRun(143);
new Thread(p).start();

At:调用Start方法和调用run方法的区别?

调用start会开启线程,让开启的线程去执行run方法中的线程任务,

 直接调用run方法,线程并未开启,去执行run方法的只有主线程(main)。

-----------------------------------------------方式一:继承Thread----------------------------------------------------------------

/*
 * 如何获取线程对象的名称呢?
 * public final String getName():获取线程的名称。
 * 如何设置线程对象的名称呢?
 * public final void setName(String name):设置线程的名称
 *
 * 针对不是Thread类的子类中如何获取线程对象名称呢?
 * public static Thread currentThread():返回当前正在执行的线程对象
 * Thread.currentThread().getName()
 */

 public class MyThread extends Thread {

     public MyThread() {
} public MyThread(String name){
super(name);
} @Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
}

MyThread

 public class MyThreadDemo {
public static void main(String[] args) {
// 创建线程对象
//无参构造+setXxx()
// MyThread my1 = new MyThread();
// MyThread my2 = new MyThread();
// //调用方法设置名称
// my1.setName("林青霞");
// my2.setName("刘意");
// my1.start();
// my2.start(); //带参构造方法给线程起名字
// MyThread my1 = new MyThread("林青霞");
// MyThread my2 = new MyThread("刘意");
// my1.start();
// my2.start(); //我要获取main方法所在的线程对象的名称,该怎么办呢?
//遇到这种情况,Thread类提供了一个很好玩的方法:
//public static Thread currentThread():返回当前正在执行的线程对象
System.out.println(Thread.currentThread().getName());
}
}

MyThreadDemo

/*
 * public final void setDaemon(boolean on):将该线程标记为守护线程或用户线程。
 * 当正在运行的线程都是守护线程时,Java 虚拟机退出。 该方法必须在启动线程前调用。
 *
 */

 public class ThreadDaemon extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
}

ThreadDaemon

 public class ThreadDaemonDemo {
public static void main(String[] args) {
ThreadDaemon td1 = new ThreadDaemon();
ThreadDaemon td2 = new ThreadDaemon(); td1.setName("关羽");
td2.setName("张飞"); // 设置守护线程
td1.setDaemon(true);
td2.setDaemon(true); td1.start();
td2.start(); Thread.currentThread().setName("刘备");
for (int x = 0; x < 5; x++) {
System.out.println(Thread.currentThread().getName() + ":" + x);
}
}
}

ThreadDaemonDemo

/*
 * public final void join():等待该线程终止。
 */

 public class ThreadJoin extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
}

ThreadJoin

 public class ThreadJoinDemo {
public static void main(String[] args) {
ThreadJoin tj1 = new ThreadJoin();
ThreadJoin tj2 = new ThreadJoin();
ThreadJoin tj3 = new ThreadJoin(); tj1.setName("李渊");
tj2.setName("李世民");
tj3.setName("李元霸"); tj1.start();
try {
tj1.join();
} catch (InterruptedException e) {
e.printStackTrace();
} tj2.start();
tj3.start();
}
}

ThreadJoinDemo

/*
 * 我们的线程没有设置优先级,肯定有默认优先级。
 * 那么,默认优先级是多少呢?
 * 如何获取线程对象的优先级?
 *         public final int getPriority():返回线程对象的优先级
 * 如何设置线程对象的优先级呢?
 *         public final void setPriority(int newPriority):更改线程的优先级。
 *
 * 注意:
 *         线程默认优先级是5。
 *         线程优先级的范围是:1-10。
 *         线程优先级高仅仅表示线程获取的 CPU时间片的几率高,但是要在次数比较多,或者多次运行的时候才能看到比较好的效果。
 *         
 * IllegalArgumentException:非法参数异常。
 * 抛出的异常表明向方法传递了一个不合法或不正确的参数。
 *
 */

 public class ThreadPriority extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
}
}
}

ThreadPriority

 public class ThreadPriorityDemo {
public static void main(String[] args) {
ThreadPriority tp1 = new ThreadPriority();
ThreadPriority tp2 = new ThreadPriority();
ThreadPriority tp3 = new ThreadPriority(); tp1.setName("东方不败");
tp2.setName("岳不群");
tp3.setName("林平之"); // 获取默认优先级
// System.out.println(tp1.getPriority());
// System.out.println(tp2.getPriority());
// System.out.println(tp3.getPriority()); // 设置线程优先级
// tp1.setPriority(100000); //设置正确的线程优先级
tp1.setPriority(10);
tp2.setPriority(1); tp1.start();
tp2.start();
tp3.start();
}
}

ThreadPriorityDemo

/*
 * 线程休眠
 *        public static void sleep(long millis)
 */

 public class ThreadSleep extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x + ",日期:" + new Date());
// 睡眠1秒钟
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

ThreadSleep

 public class ThreadSleepDemo {
public static void main(String[] args) {
ThreadSleep ts1 = new ThreadSleep();
ThreadSleep ts2 = new ThreadSleep();
ThreadSleep ts3 = new ThreadSleep(); ts1.setName("林青霞");
ts2.setName("林志玲");
ts3.setName("林志颖"); ts1.start();
ts2.start();
ts3.start();
}
}

ThreadSleepDemo

/*
 * public final void stop():让线程停止,过时了,但是还可以使用。
 * public void interrupt():中断线程。 把线程的状态终止,并抛出一个InterruptedException。
 */

 import java.util.Date;

 public class ThreadStop extends Thread {
@Override
public void run() {
System.out.println("开始执行:" + new Date()); // 休息10秒钟
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// e.printStackTrace();
System.out.println("线程被终止了");
} System.out.println("结束执行:" + new Date());
}
}

ThreadStop

 public class ThreadStopDemo {
public static void main(String[] args) {
ThreadStop ts = new ThreadStop();
ts.start(); // 中断sleep
try {
Thread.sleep(3000);
// ts.stop();
ts.interrupt();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

ThreadStopDemo

/*
 * public static void yield():暂停当前正在执行的线程对象,并执行其他线程。
 * 让多个线程的执行更和谐,但是不能靠它保证一人一次。
 */

 public class ThreadYield extends Thread {
@Override
public void run() {
for (int x = 0; x < 100; x++) {
System.out.println(getName() + ":" + x);
Thread.yield();
}
}
}

ThreadYield

 public class ThreadYieldDemo {
public static void main(String[] args) {
ThreadYield ty1 = new ThreadYield();
ThreadYield ty2 = new ThreadYield(); ty1.setName("林青霞");
ty2.setName("刘意"); ty1.start();
ty2.start();
}
}

ThreadYieldDemo

=============================方式2:实现Runnable接口==========================

/*
 * 方式2:实现Runnable接口
 * 步骤:
 *         A:自定义类MyRunnable实现Runnable接口
 *         B:重写run()方法
 *         C:创建MyRunnable类的对象
 *         D:创建Thread类的对象,并把C步骤的对象作为构造参数传递
 */

 public class MyRunnable implements Runnable {

     @Override
public void run() {
for (int x = 0; x < 100; x++) {
// 由于实现接口的方式就不能直接使用Thread类的方法了,但是可以间接的使用
System.out.println(Thread.currentThread().getName() + ":" + x);
}
} }

MyRunnable

 public class MyRunnableDemo {
public static void main(String[] args) {
// 创建MyRunnable类的对象
MyRunnable my = new MyRunnable(); // 创建Thread类的对象,并把C步骤的对象作为构造参数传递
// Thread(Runnable target)
// Thread t1 = new Thread(my);
// Thread t2 = new Thread(my);
// t1.setName("林青霞");
// t2.setName("刘意"); // Thread(Runnable target, String name)
Thread t1 = new Thread(my, "林青霞");
Thread t2 = new Thread(my, "刘意"); t1.start();
t2.start();
}
}

MyRunnableDemo

上一篇:Java基础——集合(持续更新中)


下一篇:Windows激活客户端 已停止工作