一：线程概念
正如计算机操作系统都有进程的概念：在系统中相互隔离、独立运行的程序(而实际上CPU在某个时间点上只能执行一个程序，只是系统在快速连续的切换程序的运行)。
在程序的运行中，我们一样能执行多个任务，每个任务称为一个线程，能够同时运行多个线程的程序称为多线程程序。每一个Java应用程序都至少有一个线程：主线程。当Java应用程序启动时，虚拟机就会创建主线程，并在线程中调用
main()方法。
JVM除了主线程通常还会创建一些不可见的线程，如自动垃圾收集器线程、对象终止或其他的相关线程。
线程与进程的区别：
每个进程都有自己的一组完整的变量，而线程是共享相同的数据。
二：创建一个线程(一)
创建一个类继承Thread，然后覆盖thread中的run()方法，这样就让类本身也成了线程。
Thread包含了一个特殊的方法，叫做start()，他的作用是对线程进行特殊的初始化，然后调用run()方法。所以整个步骤包括：调用构造来创建对象，然后用start()配置线程，在调用run()方法。
//示例1：
package example;
public class TestThread extends Thread{
private static int threadCount = 0;
private int i = 5;
private int threadnumber;
private TestThread(){
threadnumber = ++ threadCount;
System.out.println("创建线程："+threadnumber);
}
public void run(){
while(true){
System.out.println("运行线程"+threadnumber+"("+i+")");
if(--i==0)
return;
}
}
public static void main(String[] args) {
for(int j=0;j<5;j++){
new TestThread().start();
System.out.println("所有进程开启完毕");
}
}
}
三：创建线程(二)
我们还可以通过实现Runnable接口并实现接口中定义的唯一的方法run()来创建一个新的线程。
在将实现Runnable接口的类在程序中创建一个实例，并将这个实例做为Thread构造函数的参数创建一个新的实例，调用这个实例的start()方法，它将会调用run()来实现多线程。
//示例2：
package example;
public class TestThread2 implements Runnable{
private static int threadCount = 0;
private int i = 5;
private int threadnumber;
private TestThread2(){
threadnumber = ++ threadCount;
System.out.println("创建线程："+threadnumber);
}
public void run(){
while(true){
System.out.println("运行线程"+threadnumber+"("+i+")");
if(--i==0)
return;
}
}
public static void main(String[] args) {
for(int j=0;j<5;j++){
new Thread(new TestThread2()).start();
System.out.println("所有进程开启完毕");
}
}
}
与上一个示例相比，有什么区别。
四：线程的状态
线程的状态可分为五种：
新建(new)
可运行(Runnable)
运行(Running)
阻塞(Blocked)
死亡(Dead)
五：线程控制
1.测试线程：isAlive()
2.中断线程：Thread.sleep(),Thread.yield()
3.设置优先级：getPriority(),setPriority()
六：线程的join()方法
join()方法是一个等待另一个线程完成的方法
当调用Thread.join(),调用线程将阻塞，直到被join()方法加入的线程完成为止.
七：线程控制的方法
start() : 新建的线程进入Runnable状态
run() : 线程进入Running 状态
wait() :线程进入等待状态，等待被notify，这是一个对象方法，而不是线程方法
notify()/notifyAll() :唤醒其他的线程，这是一个对象方法，而不是线程方法
yield() :线程放弃执行，使其他优先级不低于此线程的线程有机会运行
getPriority()/setPriority() :获得/设置线程优先级
suspend() :挂起该线程，Deprecated，不推荐使用
resume() :唤醒该线程，与suspend相对，Deprecated，不推荐使用
sleep(): 线程睡眠指定的一段时间
join() :调用这个方法的主线程，会等待加入的子线程完成
八：多线程的作用
JAVA中的多线程是通过虚拟CPU来实现的，通过java.lang.Thread类来实现虚拟其内部的功能，能接收和处理传递给它的代码和数据，并提供了独立运行的控制功能。
多线程的应用很广泛，如一个浏览器同时下载多幅图片，一个服务器能够响应并发的请求，还有JAVA程序后台的垃圾收集器都是多线程的应用。
九：Java线程模型
虚拟的CPU，由java.lang.Thread类封装和虚拟CPU来实现。
CPU所执行的代码，传递给Thread类对象。
CPU所处理的数据，传递给Thread类对象。
十：同步的安全性
嵌套同步是安全的。
同步化方法：
synchronized可以写在放法前，表示锁定this
void 方法名(){
synchronized(this){}
}
==
synchronized void 方法名(){}
十一：多线程编程一般规则
如果两个或两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。
如果一个线程必须等待一个对象状态发生变化，那么他应该在对象内部等待，而不是在外部。他可以通过调用一个被同步的方法，并让这个方法调用wait()。
每当一个方法返回某个对象的锁时，它应当调用notifyAll()来让等待队列中的其他线程有机会执行。
wait()和notify()/notifyAll()是Object类方法，而不是Thread类的方法。
针对wait()、notify()/notifyAll()使用旋锁（spin lock）；
优先使用notifyAll()而不是notify()；
按照固定的顺序获得多个对象锁，以避免死锁；
不要对上锁的对象改变它的引用；
不要滥用同步机制，避免无谓的同步控制。
十二：定时器示例
//示例3：
package example;
import java.util.Timer;
import java.util.TimerTask;
public class TimerWork {
public static void main(String args[]) {
Timer tmr = new Timer();
tmr.schedule(new TimePrinter(), 0, 2000);
}
}
class TimePrinter extends TimerTask {
int i = 0;
public void run() {
System.out.println("No." + i++);
}
}
//BounceThread
package example;
import java.awt.geom.*;
public class Ball {
private static final int XSIZE = 15;
private static final int YSIZE = 15;
private double x = Math.random()*100;
private double y = Math.random()*100;
private double dx = 1;
private double dy = 1;
public void move(Rectangle2D bounds) {
x += dx;
y += dy;
if (x < bounds.getMinX()) {
x = bounds.getMinX();
dx = -dx;
}
if (x + XSIZE >= bounds.getMaxX()) {
x = bounds.getMaxX() - XSIZE;
dx = -dx;
}
if (y < bounds.getMinY()) {
y = bounds.getMinY();
dy = -dy;
}
if (y + YSIZE >= bounds.getMaxY()) {
y = bounds.getMaxY() - YSIZE;
dy = -dy;
}
}
public Ellipse2D getShape() {
return new Ellipse2D.Double(x, y, XSIZE, YSIZE);
}
}
package example;
import java.awt.*;
import java.util.*;
import javax.swing.*;
public class BallComponent extends JComponent {
public void add(Ball b) {
balls.add(b);
}
public void paintComponent(Graphics g) {
Graphics2D g2 = (Graphics2D) g;
for (Ball b : balls) {
g2.fill(b.getShape());
}
}
private ArrayList<Ball> balls = new ArrayList<Ball>();
}
package example;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class BounceThread {
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
JFrame frame = new BounceFrame();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
});
}
}
class BallRunnable implements Runnable {
private Ball ball;
private Component component;
public static final int STEPS = 10000;
public static final int DELAY = 10;
public BallRunnable(Ball aBall, Component aComponent) {
ball = aBall;
component = aComponent;
}
public void run() {
try {
for (int i = 1;; i++) {
ball.move(component.getBounds());
component.repaint();
Thread.sleep(DELAY);
}
} catch (InterruptedException e) {
}
}
}
class BounceFrame extends JFrame {
public BounceFrame() {
setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
setTitle("BounceThread");
comp = new BallComponent();
add(comp, BorderLayout.CENTER);
JPanel buttonPanel = new JPanel();
addButton(buttonPanel, "Start", new ActionListener() {
public void actionPerformed(ActionEvent event) {
addBall();
}
});
addButton(buttonPanel, "Close", new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.exit(0);
}
});
add(buttonPanel, BorderLayout.SOUTH);
}
public void addButton(Container c, String title, ActionListener listener) {
JButton button = new JButton(title);
c.add(button);
button.addActionListener(listener);
}
public void addBall() {
Ball b = new Ball();
comp.add(b);
Runnable r = new BallRunnable(b, comp);
Thread t = new Thread(r);
t.start();
}
private BallComponent comp;
public static final int DEFAULT_WIDTH = 450;
public static final int DEFAULT_HEIGHT = 350;
}
分享到：
相关推荐
thread线程的基本入门文档 适合入门学习 讲的比较广 深度说的不多
thread 线程类 实现runnable接口
Thread线程和ThreadPool线程池 Thread：我们可以开启一个线程。但是请大家记住：线程开启会在空间和时间上有不小的开销。所以，不能随便开。 ThreadPool：会根据你的CPU的核心数开启一个最合适的线程数量。如果你...
线程间同步和通信之信号量（动态），通过按键传递信号量控制LED灯的亮灭
linux thread线程创建示例代码，设置线程属性，PTHREAD_CREATE_DETACHED
C#thread线程类[定义].pdf
下面小编就为大家带来一篇Android中断并重启一个Thread线程的简单方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
我们编程常常遇到好多东西一下就想不起来了，我这里有一个很好的样例，你看看吧！帮助你编写一个好程序，这是一个经典的线程列子
很好的多线程例子，学习会很有用的哦，记得来下载喔，谢谢各位！
thread.zip ，线程的理解实例，线程
基于STM32H750VBT6的创建线程例程，IDE使用的RT-Thread studio
有两种方法给线程传递数据。第一种是使用带委托参数的Tread类构造行数；另一种方式是程序员自己创建一个类，把线程的方法定义为实例方法，这样可以初始化实例的数据，然后就可以用Start（）方法启动线程。
基于博客中Rt-Thread学习笔记-----线程创建（三）的测试工程。里面包含RTThread的单线程动态、静态创建，以及多线程动态静态的配合（基于Stm32F103Zet6、Keil5、rtthread3.1.3）
继承Thread类： 1必须重写run 方法：里面放置的实际的线程体 2 启动线程： 3创建Thread对象 4调用Thread对象的start 方法启动线程
stm32f1 RT-thread 例程
上传这个主要是因为我没分儿了哈哈.. 我也是刚开始学习安卓开发,希望这个可以帮到有类似需求的朋友
AndroidChannel is helper library for inter thread communication between main thread and worker thread. AndroidChannel uses HandlerThread for inter thread communication. Setup Gradle dependencies { .....
主要介绍了以下几点： 1.moveToThread创建线程。 2.connect信号槽判断连接方式。 3.如何使用信号返回值。 4.确定创建类的所属线程。
源码
NULL 博文链接：https://geyubin.iteye.com/blog/544602