java 线程thread基础知识点总结

1.线程Thread是指程序的运行流程。多线程的机制可以同时运行多个程序块，使程序运行的效率更高，也解决了传统程序设计语言所无法解决的问题。

2.如果在类里面要激活线程，必须先做好下面两项准备：
1.此类必须是扩展自Thread类，使自己成为它的子类。
2.线程的处理程序必须编在run()方法内。

3.run()方法是定义在Thread类里面的一个方法，因此把线程的程序代码编写在run()方法里，所做的就是对Thread.run()方法的复写。

4.Runnable接口里声明了抽象的run()方法，因此必须在实现了Runnable接口的类里明确定义run()方法(必须实现run()方法)。

5.每一个线程，在其创建和消亡之前，均会处于下列五种状态之一：创建、就绪、运行、阻塞、终止。

6.暂停状态的线程可由下列的情况所产生：
1.该线程调用对象的wait()方法时；
2.该线程本身调用sleep()方法时；
3.该线程和另一个线程join()在一起时。

7.被冻结因素消失的原因有：
1.如果线程是由调用对象的wait()方法所冻结，则该对象的notify()方法被调用时可解除冻结；
2.线程进入休眠sleep状态，但指定的休眠时间到了。

8.当线程的run()方法运行结束，或是由线程调用它的stop()方法时，由线程进入消亡状态。

9.Thread类里的sleep()方法可以用来控制线程的休眠状态，休眠的时间要视sleep()里的参数而定。

10.要强制某一线程运行，可以用join()方法。

11.join()方法会抛出InterruptedException的异常，所以编写时必须把join()方法编写在try-catch块内进行异常的捕获。

12.当多个线程对象操纵同一共享资源时，要使用synchronized关键字来进行资源的同步处理，可以是synchronized(this){要同步的代码块} 或者是声明方法时使用synchronized关键字

下面就做个例子：
 
一、标准例子
 
定义了MyThreadLocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。
 

 代码如下 复制代码

/**
* 使用了ThreadLocal的类
*
* @author leizhimin 2010-1-5 10:35:27
*/
public class MyThreadLocal {
        //定义了一个ThreadLocal变量，用来保存int或Integer数据
        private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
                @Override
                protected Integer initialValue() {
                        return 0;
                }
        };

        public Integer getNextNum() {
                //将tl的值获取后加1，并更新设置t1的值
                tl.set(tl.get() + 1);
                return tl.get();
        }
}
/**
* 测试线程
*
* @author leizhimin 2010-1-5 10:39:18
*/
public class TestThread extends Thread {
        private MyThreadLocal tlt = new MyThreadLocal();

        public TestThread(MyThreadLocal tlt) {
                this.tlt = tlt;
        }

        @Override
        public void run() {
                for (int i = 0; i < 3; i++) {
                        System.out.println(Thread.currentThread().getName() + "t" + tlt.getNextNum());
                }
        }
}
/**
* ThreadLocal测试
*
* @author leizhimin 2010-1-5 10:43:48
*/
public class Test {
        public static void main(String[] args) {
                MyThreadLocal tlt = new MyThreadLocal();
                Thread t1 = new TestThread(tlt);
                Thread t2 = new TestThread(tlt);
                Thread t3 = new TestThread(tlt);
                Thread t4 = new TestThread(tlt);
                t1.start();
                t2.start();
                t3.start();
                t4.start();

        }
}

可以看出，三个线程各自独立编号，互不影响：

hread-0  1
Thread-1  1
Thread-0  2
Thread-1  2
Thread-0  3
Thread-1  3
Thread-2  1
Thread-3  1
Thread-2  2
Thread-3  2
Thread-2  3
Thread-3  3

Process finished with exit code 0
tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的Map随着线程的增多，会创建很多Integer对象。只是Integer和int已经通用了。所以感觉不到Integer的对象属性。
 
二、不用ThreadLocal
 
假如不用ThreadLocal，只需要将MyThreadLocal类重新定义为：

 代码如下 复制代码

/**
* 使用了ThreadLocal的类
*
* @author leizhimin 2010-1-5 10:35:27
*/
public class MyThreadLocal {
        private Integer t1 = 0;
        public Integer getNextNum(){
                return t1=t1+1;
        }

 

//        //定义了一个ThreadLocal变量，用来保存int或Integer数据
//        private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
//                @Override
//                protected Integer initialValue() {
//                        return 0;
//                }
//        };
//
//        public Integer getNextNum() {
//                //将tl的值获取后加1，并更新设置t1的值
//                tl.set(tl.get() + 1);
//                return tl.get();
//        }
}

然后运行测试：
Thread-2  1
Thread-2  2
Thread-1  4
Thread-1  6
Thread-3  3
Thread-3  9
Thread-3  10
Thread-1  8
Thread-0  7
Thread-0  11
Thread-0  12
Thread-2  5

Process finished with exit code 0
从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。
 
三、自己实现个ThreadLocal
 

 代码如下 复制代码

package com.lavasoft.test2;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

/**
* 使用了ThreadLocal的类
*
* @author leizhimin 2010-1-5 10:35:27
*/
public class MyThreadLocal {

        //定义了一个ThreadLocal变量，用来保存int或Integer数据
        private com.lavasoft.test2.ThreadLocal<Integer> tl = new com.lavasoft.test2.ThreadLocal<Integer>() {
                @Override
                protected Integer initialValue() {
                        return 0;
                }
        };

        public Integer getNextNum() {
                //将tl的值获取后加1，并更新设置t1的值
                tl.set(tl.get() + 1);
                return tl.get();
        }
}

class ThreadLocal<T> {
        private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());

        public ThreadLocal() {
        }

        protected T initialValue() {
                return null;
        }

        public T get() {
                Thread t = Thread.currentThread();
                T obj = map.get(t);
                if (obj == null && !map.containsKey(t)) {
                        obj = initialValue();
                        map.put(t, obj);
                }
                return obj;
        }

        public void set(T value) {
                map.put(Thread.currentThread(), value);
        }

        public void remove() {
                map.remove(Thread.currentThread());
        }
}

运行测试：
Thread-0  1
Thread-0  2
Thread-0  3
Thread-2  1
Thread-2  2
Thread-3  1
Thread-2  3
Thread-3  2
Thread-1  1
Thread-3  3
Thread-1  2
Thread-1  3

Process finished with exit code 0
很意外，这个山寨版的ThreadLocal也同样运行很好，实现了JavaAPI中ThreadLocal的功能。

多线程优点：  

A、进程之间不能共享内存，但线程之间共享内存非常容易。   
B、系统创建进程需要为该进程重新分配系统资源，但创建线程则代价要小得多，因此使用线程来实现多任务并发比多进程的效率高。   
C、Java语言内置多线程功能支持，而不是单纯的作为底层操作系统的调度方式，从而简化Java的多线程编程

时间： 2024-07-31 04:28:35

java 线程thread基础知识点总结的相关文章

关于java线程的基础知识

问题描述 关于java线程的基础知识 public class ThreadTest { public static void main(String[] args) throws InterruptedException { // TODO Auto-generated method stub Runnable r=new Runnable() { @Override public void run() { // TODO Auto-generated method stub try{ Thr

Java线程并发控制基础知识

线程池 推荐用ThreadPoolExecutor的工厂构造类Executors来管理线程池,线程复用线程池开销较每次申请新线程小,具体看代码以及注释 public class TestThread { /** * 使用线程池的方式是复用线程的(推荐) * 而不使用线程池的方式是每次都要创建线程 * Executors.newCachedThreadPool(),该方法返回的线程池是没有线程上限的,可能会导致过多的内存占用 * 建议使用Executors.newFixedThreadPool(n

JAVA的一些基础知识点

问题描述 1.floatresultfloatresultf这两个变量分别定义了一个双精度浮点数和单精度浮点数吗?2.floatf1=20.32f,f2=5.3f;为什么f1-f2=15.099995(3.1) 解决方案 解决方案二:1.floatresultfloatresultf这两个变量分别定义了一个双精度浮点数和单精度浮点数吗?命名不区分,只有常量带f才区分2.floatf1=20.32f,f2=5.3f;为什么f1-f2=15.099995(3.1)默认print格式化的是6位小数存储

Java线程编程中Thread类的基础学习教程_java

一.线程的状态 在正式学习Thread类中的具体方法之前,我们先来了解一下线程有哪些状态,这个将会有助于后面对Thread类中的方法的理解. 线程从创建到最终的消亡,要经历若干个状态.一般来说,线程包括以下这几个状态:创建(new).就绪(runnable).运行(running).阻塞(blocked).time waiting.waiting.消亡(dead). 当需要新起一个线程来执行某个子任务时,就创建了一个线程.但是线程创建之后,不会立即进入就绪状态,因为线程的运行需要一些条件(比如内

Java多线程编程基础之线程对象

在进入java平台的线程对象之前,基于基础篇(一)的一些问题,我先插入两个基本概念. [线程的并发与并行] 在单CPU系统中,系统调度在某一时刻只能让一个线程运行,虽然这种调试机制有多种形式(大多数是时间片轮巡为主),但无论如何,要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent).而在多CPU系统中,可以让两个以上的线程同时运行,这种可以同时让两个以上线程同时运行的方式叫做并行(parallel). 在上面包括以后的所有论述中,请各位朋友谅解,我无法用最准确的词语来定义储

java线程编程（一）：线程基础

在学习java中,我发现有关于对线程的讲解比较少,我打算为一些java初学者提一些关于线程方面的参考, 为深入学习java奠定基础.我本着共同进步的原则特写下了关于java线程编程的一系列文章 java线程编程(一):线程基础 ◆线程(thread)其实是控制线程(thread of control)的缩写. 每一个线程都是独立的,因此线程中的每个方法的局部变量都是和其他线程隔离开的,这些变量完全是私有的,因此对于 线程而言,是没有办法访问其他线程的局部变量的.如果两个线程同时访问同一个方法,则

《Java线程与并发编程实践》- 第1章 Thread和Runnable

第1章 Thread和Runnable Java线程与并发编程实践 Java程序是通过线程执行的,线程在程序中具有独立的执行路径.当多条线程执行时,它们彼此之间的路径可以不同.举个例子,一条线程可能在执行switch语句的某个case分支,另一条线程很可能在执行其他case分支. 每个Java应用程序都有一个执行main()函数的默认主线程.应用程序也可以创建线程在后台操作时间密集型任务,以确保对用户的响应.这些封装了代码执行序列的线程对象就被称为runnable. Java虚拟机给每条线程分配

Java多线程：“基础篇”09之interrupt()和线程终止方式

1. interrupt()说明 在介绍终止线程的方式之前,有必要先对interrupt()进行了解. 关于interrupt(),java的djk文档描述如下: http://docs.oracle.com/javase/7/docs/api/ Interrupts this thread. Unless the current thread is interrupting itself, which is always permitted, the checkAccess method of

Java多线程编程基础之线程和多线程

[写在前面] 随着计算机技术的发展,编程模型也越来越复杂多样化.但多线程编程模型 是目前计算机系统架构的最终模型.随着CPU主频的不断攀升,X86架构的硬件已 经成为瓶,在这种架构的CPU主频最高为4G.事实上目前3.6G主频的CPU已经接近了顶峰. 如果不能从根本上更新当前CPU的架构(在很长一段时间内还不太可能),那么 继续提高CPU性能的方法就是超线程CPU模式.那么,作业系统.应用程序要发挥 CPU的最大性能,就是要改变到以多线程编程模型为主的并行处理系统和并发式 应用程序. 所以,掌握