关于线程

1.什么线程，什么是进程，什么是程序？ 线程：是一个独立的运行单位。一个程序如果不启动线程一般只有一条执行路径，即按main方法中相互调用的顺序执行，启动线程，程序就会有不同的执行路径，执行语句可能会同时启动。 进程：正在运行的程序；进程可以是一个或者多个线程组成，是一个静态的概念，进程例如exe、class文件等。 程序：文件的形式在磁盘中存在。

2.注意：

【1】Java中的线程是通过java.lang.Thread类继承
【2】 线程启动必须调用Thread的start方法。
【3】 Thread 类也实现了Runable接口，所以也实现了其中的run方法。

3.JAVA中两种创建线程的方式

【1】继承Thread类并重写里面的run方法

 class MyThread extends Thread{

      public void run(){ };

}

然后创建该类对象，调用start方法启动线程

【2】定义线程类实现Runnable的接口，重写run方法

class Runner implements Runnable
{
public void run()

}

然后创建该类对象，将该对象作为参数传给Thread类的构造方法，再创建Thread类的对象，用该对象调用start方法启动线程

4.代码示例：

 

package com.hun.zyf0531v1;

import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

public class ListenerDemo extends JFrame {

	private int i = 1;//表示开启了多少个线程
	
	public static void main(String[] args) {
		ListenerDemo ld = new ListenerDemo();
		ld.initUI();
	}

	public void initUI() {
		this.setSize(600, 600);
		this.setTitle("线程");
		this.setDefaultCloseOperation(3);
		this.setLocationRelativeTo(null);
		this.setResizable(false);    //禁止调整窗体大小
		this.setLayout(new FlowLayout());

		JButton jbu1 = new JButton("执行100000次循环");

		JButton jbu2 = new JButton("执行1000000次循环");

		JButton jbu3 = new JButton("执行10000000次循环");

		this.add(jbu3);
		this.add(jbu2);
		this.add(jbu1);

		// 在匿名内部类中使用变量时，必须要将变量设置为final，表示变量的值不允许改变。
		final JTextArea jta = new JTextArea(10, 40); //显示纯文本的多行区域
		JScrollPane jsp = new JScrollPane(jta);      //添加滚动条
		// jsp.add(jta);
		this.add(jsp);

		// 匿名内部类
		ActionListener al = new ActionListener() {

			@Override
			public void actionPerformed(ActionEvent e) {
				String ac = e.getActionCommand();
				RunnableDemo rd;
				Thread t;
				switch (ac) {
				case "执行100000次循环":
					// 实例化线程类的对象，传递参数
					rd = new RunnableDemo(jta, 100000,i);
					// 用Thread类来封装rd？为什么？
					t = new Thread(rd);
					// 启动线程
					t.start();

					break;

				case "执行1000000次循环":
					rd = new RunnableDemo(jta, 1000000,i);
					// 用Thread类来封装rd
					t = new Thread(rd);
					// 启动线程
					t.start();
					break;

				case "执行10000000次循环":
					rd = new RunnableDemo(jta, 10000000,i);
					// 用Thread类来封装rd
					t = new Thread(rd);
					// 启动线程
					t.start();
					break;
				}
				i++;
			}

		};

		jbu1.addActionListener(al);
		jbu2.addActionListener(al);
		jbu3.addActionListener(al);

		this.setVisible(true);
	}

}

 

package com.hun.zyf0531v1;

/**
 * 定义一个ThreadDemo类，该类继承Thread线程类
 */
public class ThreadDemo extends Thread {

	public static void main(String[] args) {
		//实例化一个Thread类的对象
		ThreadDemo td = new ThreadDemo();
		td.start();//启动线程
		System.out.println("=======调用方法结束");
	}

	/**
	 * 线程的运行方法
	 */
	public void run(){
		a();
		b();//调用方法时会停止1秒执行
		c();
		d();
	}
	

	public void a(){
		System.out.println("a方法");
	}

	public void b(){
		try {
			Thread.sleep(1000);//停止1秒后再继续执行
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("b方法");
	}
	

	public void c(){
		System.out.println("c方法");
	}
	

	public void d(){
		System.out.println("d方法");
	}

}

 

package com.hun.zyf0531v1;

import javax.swing.JTextArea;

public class RunnableDemo implements Runnable {

	private JTextArea jta;
	private int count,in;
	

	public RunnableDemo(JTextArea jta, int count,int in) {
		this.jta = jta;
		this.count = count;
		this.in = in;
	}

	/**
	 * 重写线程的运行方法
	 */
	@Override
	public void run() {
		for (int i = 1; i <= count; i++) {
			jta.append("第"+in+"个线程，当前循环了" + i + "次\n");
		}
	}

} 

 

package com.hun.zyf0531v1;

public class Test {

	public static void main(String[] args) {
		a();
		b();
		c();
		d();
	}
	
	public static void a(){
		System.out.println("a方法");
	}

	public static void b(){
		System.out.println("b方法");
	}
	

	public static void c(){
		System.out.println("c方法");
	}
	

	public static void d(){
		System.out.println("d方法");
	}
}