Java基础之多线程
来源:互联网 发布:马叔叔 淘宝 编辑:程序博客网 时间:2024/05/22 17:35
Java基础之多线程
- 进程:进程是一个静态的概念
- 线程:一个进程里面有一个主线程叫main()方法,是一个程序里面的,一个进程里面不同的执行路径。
- 在同一个时间点上,一个CPU只能支持一个线程在执行。因为CPU运行的速度很快,因此我们看起来的感觉就像是多线程一样。
什么才是真正的多线程?如果你的机器是双CPU,或者是双核,这确确实实是多线程。
在JAVA里面,JAVA的线程是通过java.lang.Thread类来实现的,每一个Thread对象代表一个新的线程。创建一个新线程出来有两种方法:第一个是从Thread类继承,另一个是实现接口runnable。VM启动时会有一个由主方法(public static void main())所定义的线程,这个线程叫主线程。可以通过创建Thread的实例来创建新的线程。你只要new一个Thread对象,一个新的线程也就出现了。每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的,方法run()称为线程体。
范例1:使用实现Runnable接口创建和启动新线程
开辟一个新的线程来调用run方法
package cn.galc.test;
public class TestThread1{
public static void main(String args[]){
Runner1 r1 = new Runner1();//这里new了一个线程类的对象出来
//r1.run();//这个称为方法调用,方法调用的执行是等run()方法执行完之后才会继续执行main()方法
Thread t = new Thread(r1);//要启动一个新的线程就必须new一个Thread对象出来
//这里使用的是Thread(Runnable target) 这构造方法
t.start();//启动新开辟的线程,新线程执行的是run()方法,新线程与主线程会一起并行执行
for(int i=0;i<10;i++){
System.out.println("maintheod:"+i);
}
}
}
/*定义一个类用来实现Runnable接口,实现Runnable接口就表示这个类是一个线程类*/
class Runner1 implements Runnable{
public void run(){
for(int i=0;i<10;i++){
System.out.println("Runner1:"+i);
}
}
}
范例2:继承Thread类,并重写其run()方法创建和启动新的线程
package cn.galc.test;
/*线程创建与启动的第二种方法:定义Thread的子类并实现run()方法*/
public class TestThread2{
public static void main(String args[]){
Runner2 r2 = new Runner2();
r2.start();//调用start()方法启动新开辟的线程
for(int i=0;i<=10;i++){
System.out.println("mainMethod:"+i);
}
}
}
/*Runner2类从Thread类继承
通过实例化Runner2类的一个对象就可以开辟一个新的线程
调用从Thread类继承来的start()方法就可以启动新开辟的线程*/
class Runner2 extends Thread{
public void run(){//重写run()方法的实现
for(int i=0;i<=10;i++){
System.out.println("Runner2:"+i);
}
}
}注:使用实现Runnable接口和继承Thread类这两种开辟新线程的方法的选择应该优先选择实现Runnable接口这种方式去开辟一个新的线程。因为接口的实现可以实现多个,而类的继承只能是单继承。因此在开辟新线程时能够使用Runnable接口就尽量不要使用从Thread类继承的方式来开辟新的线程。
线程控制的基本方法:
sleep方法的应用范例:
package cn.galc.test;
import java.util.*;
public class TestThread3 {
public static void main(String args[]){
MyThread thread = new MyThread();
thread.start();//调用start()方法启动新开辟的线程
try {
/*Thread.sleep(10000);
sleep()方法是在Thread类里面声明的一个静态方法,因此可以使用Thread.sleep()的格式进行调用
*/
/*MyThread.sleep(10000);
MyThread类继承了Thread类,自然也继承了sleep()方法,所以也可以使用MyThread.sleep()的格式进行调用
*/
/*静态方法的调用可以直接使用“类名.静态方法名”
或者“对象的引用.静态方法名”的方式来调用*/
MyThread.sleep(10000);
System.out.println("主线程睡眠了10秒种后再次启动了");
//在main()方法里面调用另外一个类的静态方法时,需要使用“静态方法所在的类.静态方法名”这种方式来调用
/*
所以这里是让主线程睡眠10秒种
在哪个线程里面调用了sleep()方法就让哪个线程睡眠,所以现在是主线程睡眠了。
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
//thread.interrupt();//使用interrupt()方法去结束掉一个线程的执行并不是一个很好的做法
thread.flag=false;//改变循环条件,结束死循环
/**
* 当发生InterruptedException时,直接把循环的条件设置为false即可退出死循环,
* 继而结束掉子线程的执行,这是一种比较好的结束子线程的做法
*/
/**
* 调用interrupt()方法把正在运行的线程打断
相当于是主线程一盆凉水泼上去把正在执行分线程打断了
分线程被打断之后就会抛InterruptedException异常,这样就会执行return语句返回,结束掉线程的执行
所以这里的分线程在执行完10秒钟之后就结束掉了线程的执行
*/
}
}class MyThread extends Thread {
boolean flag = true;// 定义一个标记,用来控制循环的条件public void run() {
/*
* 注意:这里不能在run()方法的后面直接写throw Exception来抛异常,
* 因为现在是要重写从Thread类继承而来的run()方法,重写方法不能抛出比被重写的方法的不同的异常。
* 所以这里只能写try……catch()来捕获异常
*/
while (flag) {
System.out.println("==========" + new Date().toLocaleString() + "===========");
try {
/*
* 静态方法的调用格式一般为“类名.方法名”的格式去调用 在本类中声明的静态方法时调用时直接写静态方法名即可。 当然使用“类名.方法名”的格式去调用也是没有错的
*/
// MyThread.sleep(1000);//使用“类名.方法名”的格式去调用属于本类的静态方法
sleep(1000);//睡眠的时如果被打断就会抛出InterruptedException异常
// 这里是让这个新开辟的线程每隔一秒睡眠一次,然后睡眠一秒钟后再次启动该线程
// 这里在一个死循环里面每隔一秒启动一次线程,每个一秒打印出当前的系统时间
} catch (InterruptedException e) {
/*
* 睡眠的时一盘冷水泼过来就有可能会打断睡眠
* 因此让正在运行线程被一些意外的原因中断的时候有可能会抛被打扰中断(InterruptedException)的异常
*/
return;
// 线程被中断后就返回,相当于是结束线程
}
}
}
}
join方法的使用范例:
package cn.galc.test;
public class TestThread4 {
public static void main(String args[]) {
MyThread2 thread2 = new MyThread2("mythread");
// 在创建一个新的线程对象的同时给这个线程对象命名为mythread
thread2.start();// 启动线程
try {
thread2.join();// 调用join()方法合并线程,将子线程mythread合并到主线程里面
// 合并线程后,程序的执行的过程就相当于是方法的调用的执行过程
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i <= 5; i++) {
System.out.println("I am main Thread");
}
}
}class MyThread2 extends Thread {
MyThread2(String s) {
super(s);
/*
* 使用super关键字调用父类的构造方法
* 父类Thread的其中一个构造方法:“public Thread(String name)”
* 通过这样的构造方法可以给新开辟的线程命名,便于管理线程
*/
}public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("I am a\t" + getName());
// 使用父类Thread里面定义的
//public final String getName(),Returns this thread's name.
try {
sleep(1000);// 让子线程每执行一次就睡眠1秒钟
} catch (InterruptedException e) {
return;
}
}
}
}
yield方法的使用范例:
package cn.galc.test;
public class TestThread5 {
public static void main(String args[]) {
MyThread3 t1 = new MyThread3("t1");
/* 同时开辟了两条子线程t1和t2,t1和t2执行的都是run()方法 */
/* 这个程序的执行过程中总共有3个线程在并行执行,分别为子线程t1和t2以及主线程 */
MyThread3 t2 = new MyThread3("t2");
t1.start();// 启动子线程t1
t2.start();// 启动子线程t2
for (int i = 0; i <= 5; i++) {
System.out.println("I am main Thread");
}
}
}class MyThread3 extends Thread {
MyThread3(String s) {
super(s);
}public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println(getName() + ":" + i);
if (i % 2 == 0) {
yield();// 当执行到i能被2整除时当前执行的线程就让出来让另一个在执行run()方法的线程来优先执行
/*
* 在程序的运行的过程中可以看到,
* 线程t1执行到(i%2==0)次时就会让出线程让t2线程来优先执行
* 而线程t2执行到(i%2==0)次时也会让出线程给t1线程优先执行
*/
}
}
}
}sleep()方法跟yield()方法都是Thread()类的静态方法,都会使当前处于运行状态的线程放弃CPU。把运行机会让给其他线程,两个的区别在于:
(1)sleep()方法会给其他线程运行的机会,而不考虑其他线程的优先级,因此会给较低优先级线程一个机会运行,yield()方法只会给相同优先级或者更高优先级的线程一个运行机会。
(2)当前线程执行了slepp(long millis)方法后,将转向阻塞状态,参数millis指定睡眠时间,当线程执行了yield()方法后,线程仍可处于就绪状态。
- java基础之多线程
- java基础之多线程
- Java基础之多线程
- java基础之多线程
- java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Java基础之多线程
- JAVA基础之多线程
- Java基础之多线程
- java基础之多线程
- Java基础之多线程
- java基础之多线程
- java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Java基础之多线程
- Java基础之多线程
- ARM内存边界对齐以及sizeof问题
- Python 入門語法和類型
- Share Point开发部署WSP解决方案包
- linux系统中如何查看日志 (常用命令)
- java获取两个字符串中的最大匹配
- Java基础之多线程
- 3538: [Usaco2014 Open]Dueling GPS
- 【Machine Learning】3.多元线性回归
- ListView空指针
- sort/uniq/cut/wc/
- 黑马程序员---IO流(二)
- ARM、DSP、FPGA的区别
- [Leetcode]H-Index
- 两线程交替打印数字