创建线程
有两种方式,分别为继承Java.lang.Thread类与实现Java.lang.Runnable接口
继承Thread类
Thread常用的两个构造方法语法
public Thread();
public Thread(String threadName);
继承Thread类创建新线程语法:
public class ThreadTest extend Thread{
}
完成线程功能的代码放在类的run()方法中,当类继承Thread类后,就要在类中覆盖run()方法,将实现该线程功能代码写入,然后调用Thread类中的start()方法执行
语法:
public void run(){
}
例题1
package 例题;
public class 例题1 extends Thread{
public void run() {//重写方法
for(int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
}
public static void main(String[] args) {
例题1 th = new 例题1();
th.start();//启动线程
}
}
结果
实现Runnable 接口
到目前为止,线程都是通过扩展Thread类来创建的,如果本类需要继承其他类而且要实现多线程,那么就可以通过Runnable接口来实现
语法:
public class 类名 implements Runnable{
}
实现Runnable接口的程序会创建一个Thread对象,并将Runnable对象与Thread对象相关联。类中有两个构造方法
public 类名(Runnable target)
public 类名(Runnable target,String name)
这两个构造方法的参数都有Runnable实例,使用以上构造方法就可以将Runnable实例与Thread实例相关联
使用Runnable接口创建新线程步骤
1.建立Runnable对象
2.使用参数为Runnable对象的构造方法创建Thread实例
3.调用start()方法启动线程
例题2
package 例题;
import java.awt.Container;
import javax.swing.*;
public class 例题2 extends JFrame{
//图标横坐标
int count = 0;
public 例题2() {
setBounds(300,200,315,100);//窗体位置大小
Container con = getContentPane();//主容器
con.setLayout(null);//窗体不使用任何布局管理
Icon ic = new ImageIcon("src/1.gif");//导入图片
JLabel jl = new JLabel(ic);//显示图标标签
jl.setBounds(10, 10, 200, 50);//图标位置大小
Thread t = new Thread() {//定义匿名线程对象
@Override
public void run() {
while(true) {
jl.setBounds(count, 10, 200, 50);//将坐标用变量显示
try {
Thread.sleep(50);//使线程休眠50秒
}
catch(InterruptedException e) {
e.printStackTrace();
}
count += 4;//每次坐标加4
if(count >= 200) {//如果坐标达到200就回到原位置
count = -100;
}
}
}
};
t.start();//启动线程
con.add(jl);//将标签加入容器中
setVisible(true);//使窗体可见
setDefaultCloseOperation(EXIT_ON_CLOSE);//窗体关闭方式
}
public static void main(String[] args) {
new 例题2();
}
}
结果
启动一个新线程不是直接调用Thread子类对象的run方法,而是 调用Thread子类的start()方法
Thread类的start()方法产生一个新线程,该线程运行子类的run() 方法
线程的生命周期
操作线程的方法
线程的休眠
一种控制线程行为方法是调用sleep()方法,sleep()方法需要一个参数来指定该线程休眠时间,以毫秒为单位
语法:
try{
Thread.sleep(2000);
}catch(InterruptedException e){
e.printStackTrace();
}
例题3
package 例题;
import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;
import javax.swing.JFrame;
public class 例题3 extends JFrame{
//定义颜色数组
private static Color[] color = {
Color.BLACK, Color.BLUE, Color.CYAN, Color.GREEN, Color.ORANGE,
Color.YELLOW, Color.RED, Color.PINK, Color.LIGHT_GRAY
};
//创建随机对象
private static final Random rand = new Random();
//获取随机颜色方法
private static Color getC() {
return color[rand.nextInt(color.length)];
}
public 例题3() {
setBounds(550,300,0,0);
Thread t = new Thread(new Runnable() {//匿名线程对象
//定义初始坐标
int x = 30;
int y = 50;
public void run() {//无限循环
while(true) {
try {
Thread.sleep(100);//线程休眠0.1秒
}
catch(InterruptedException e) {
e.printStackTrace();
}
Graphics g = getGraphics();//获取组件绘制上下文对象
g.setColor(getC());//设置绘图颜色
g.drawLine(x, y, 100, y++);//绘制线程并递增垂直坐标
if(y >= 300) {
y = 100;
}
}
}
});
t.start();//启动线程
}
public static void main(String[] args) {
init(new 例题3(), 200, 200);
}
private static void init(JFrame frame, int iwidth, int height) {//初始化程序界面方法
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(iwidth, height);
frame.setVisible(true);
}
}
结果
线程的加入
jion()方法
当某个线程使用该方法加入另外一个线程时,另一个线程会等该线程执行完毕后再继续执行
例题4
package 例题;
import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
public class 例题4 extends JFrame{
//定义两个线程
private Thread threadA;
private Thread threadB;
//定义两个进度条组件
private JProgressBar pr = new JProgressBar();
private JProgressBar pr1 = new JProgressBar();
public static void main(String[] args) {
例题4 l = new 例题4();
l.setVisible(true);
}
public 例题4() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(200, 200, 200, 100);//窗口位置大小
getContentPane().add(pr, BorderLayout.NORTH);//将进度条设置在窗体最北面
getContentPane().add(pr1, BorderLayout.SOUTH);//将进度条设置在窗体最南面
pr.setStringPainted(true);//设置进度条显示数字字符
pr1.setStringPainted(true);
threadA = new Thread(new Runnable() {//使用匿名内部类形式初始化Thread实例
int count = 0;
public void run() {//重新方法
while(true) {
pr.setValue(++count);//设置进度条的当前值
try {
Thread.sleep(100);//使线程A休眠100毫秒
threadB.join();//使线程b调用join方法
}
catch(InterruptedException e) {
e.printStackTrace();
}
}
}
});
threadA.start();//启动线程a
threadB = new Thread(new Runnable() {
int count = 0;
public void run() {
while(true) {
pr1.setValue(++count);//设置进度条当前值
try {
Thread.sleep(100);//使线程休眠100毫秒
}
catch(InterruptedException e) {
e.printStackTrace();
}
if(count == 100)//当变量为100时跳出循环
break;
}
}
});
threadB.start();//启动线程b
}
}
结果
线程的中断
Interrupt()方法
该方法可以使线程离开run()方法,同时结束线程但程序会抛出InterruptedException异常,用户可以在处理该异常时完成线程的中断业务处理,如终止while循环。
例题5
package 例题;
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JProgressBar;
public class 例题5 extends JFrame{
public 例题5() {
JProgressBar pr = new JProgressBar();//创建进度条
getContentPane().add(pr, BorderLayout.NORTH);//将进度条放在窗体合适位置
JButton but = new JButton("停止");
getContentPane().add(but , BorderLayout.SOUTH);
pr.setStringPainted(true);//显示进度条位置
Thread t = new Thread(new Runnable() {
int count = 0;
public void run() {
while(true) {
pr.setValue(++count);//设置进度条当前值
try {
Thread.sleep(100);//使线程休眠100秒
}
catch (InterruptedException e) {
System.out.println("当前线程序被中断");//捕捉InterruptedException异常
break;
}
}
}
});
but.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
t.interrupt();//中断线程
}
});
t.start();//启动线程
}
private static void init(JFrame fe, int widht, int height) {
fe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fe.setSize(widht, height);
fe.setVisible(true);
}
public static void main(String[] args) {
init(new 例题5(),100,100);
}
}
结果
线程的礼让
Thread 类中提供了一种礼让方法,使用yield()方法表示,它只是给当前正处于运行状态的线程个提醒,告知它可以将资源礼让给其他线程,但这仅是一种暗示,没有任何一种机制保证当前线程会将资源礼让。
yield()方法使具有同样优先级的线程有进入可执行状态的机会,在当前线程放弃执行权时会再度回到就绪状体。对于支持多任务的操作系统来说,不需要调用yield()方法,因为操作系统会为线程自动分配CPU时间片来执行。
线程的优先级
每个线程都具有各自的优先级,线程的优先级可以表明在程序中该线程的重要性,如果有很多线程处于就绪状态,系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先级的线程得不到运行,而只是它运行的概率比较小,如垃圾回收线程的优先级就较低。
Thread类中包含的成员变量代表了线程的某些优先级,如Thread.MIN_PRIORITY(常数1)、Thread.MAXPRIORITY(常数10)、Thread.NORM PRIORITY(常数5)。其中,每个线程的优先级都在 Thread.MIN_PRIORITY~Thread.MAX_PRIORITY,在默认情况下其优先级都是Thread.NORM PRIORITY。每个新产生的线程都继承了父线程的优先级。
在多任务操作系统中,每个线程都会得到一小段CPU时间片运行,在时间结束时,将轮换另一个线程进入运行状态,这时系统会选择与当前线程优先级相同的线程予以运行。系统始终选择就绪状态下优先级较高的线程进入运行状态。处于各个优先级状态下的线程的运行顺序如图20.8所示。
在图20.8中,优先级为5的线程A首先得到CPU时间片;当该时间结束后,轮换到与线程A相同优先级的线程B;当线程 B的运行时间结束后,会继续轮换到线程A,直到线程A与线程B都执行完毕,才会轮换到线程C;当线程C结束后,才会轮换到线程D。
线程的优先级可以使用 setPriority()方法调整,如果使用该方法设置的优先级不在1~10,将产生IllegalArgumentException异常。
例题6
package 例题;
public class 例题6 implements Runnable{
String name;
public 例题6(String name) {
this.name = name;
}
@Override
public void run() {//完成5万次字符串拼接
String tmp = "";
for(int i = 0; i < 50000; i++) {
tmp += i;
}
System.out.println(name + "线程任务完成");
}
public static void main(String[] args) {//数字越大,线程越大,优先级越高
Thread a = new Thread(new 例题6("A"));
a.setPriority(1);
Thread b = new Thread(new 例题6("B"));
b.setPriority(3);
Thread c = new Thread(new 例题6("C"));
c.setPriority(7);
Thread d = new Thread(new 例题6("D"));
d.setPriority(10);
a.start();//启动线程
b.start();
c.start();
d.start();
}
}
结果
线程同步机制
1.同步块
Java 中提供了同步机制,可以有效地防止资源冲突。同步机制使用synchronized关键字,使用该关键字包含的代码块称为同步块,也称为临界区,语法如下:
synchronized(Object) {
}
通常将共享资源的操作放置在 synchronized 定义的区域内,这样当其他线程获取到这个锁时,就必须等待锁被释放后才可以进入该区域。Object 为任意一个对象,每个对象都存在一个标志位,并具有两个值,分别为0和1。一个线程运行到同步块时首先检查该对象的标志位,如果为0状态,表明此同步块内存在其他线程,这时当期线程处于就绪状态,直到处于同步块中的线程执行完同步块中的代码后,这时该对象的标识位设置为1,当期线程才能开始执行同步块中的代码,并将Object对象的标识位设置为0,以防止其他线程执行同步块中的代码
例题7
package 例题;
public class 例题7 implements Runnable{
int num = 10;//设置总票数
@Override
public void run() {
while(true) {//设置无限循环
synchronized (this) {//设置同步代码块
if(num > 0) {//判断票数是否大于0
try {
Thread.sleep(100);//使线程休息100秒
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "----票数" + num--);
}
}
}
}
public static void main(String[] args) {
例题7 s = new 例题7();//实例化对象
Thread s1 = new Thread(s,"线程1");//实例化线程
Thread s2 = new Thread(s,"线程2");
Thread s3 = new Thread(s,"线程3");
Thread s4 = new Thread(s,"线程4");
s1.start();//启动线程
s2.start();
s3.start();
s4.start();
}
}
同步方法
同步方法就是在方法前面用synchronized关键字修饰的方法,其语法如下:
synchronized void f(){}
当某个对象调用了同步方法时,该对象上的其他同步方法必须等待该同步方法执行完毕后才能被
执行。必须将每个能访问共享资源的方法修饰为synchronized,否则就会出错。