第一次在开源中国上发博文，简单的把以前在达内培训JAVA时的一篇日志复制共享一下。
多进程（多任务）－ 针对OS
多线程(Thread) － 一个进程内部的多任务
java语言（JVM）支持多线程编程
java.lang.Thread
Thread类由JDK提供，用于封装对JVM中线程的控制，调用C语言的类库实现。
1、创建一个线程
JVM会创建默认的线程 main用于运行main方法。
程序员可以创建自己定义的线程(定义线程的运行体)
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class MyThread extends Thread {
//重写Thread的run方法
//用于指定线程的运行体
@Override
public void run(){
//super.run();
for(int i=0;i<100000;i++){
System.out.println("run"+i);
}
}
}
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
public class TestThread {
public static void main(String[] args) {
Thread t=new MyThread();
t.start();//启动一个线程，即时返回
//t.run();//调用方法
for(int i=0;i<100000;i++){
System.out.println("main"+i);
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
Thread.sleep(long l);
作用：让当前线程(运行该方法的线程)“挂起”sleep
public class MyThread extends Thread {
//重写Thread的run方法
//用于指定线程的运行体
@Override
public void run(){
//super.run();
for(int i=0;i<100000;i++){
try{
Thread.sleep(100);
}catch(InterruptedException ee){
}
System.out.println("run"+i);
}
}
}
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
public class TestThread {
public static void main(String[] args) throws InterruptedException {
Thread t=new MyThread();
t.start();//启动一个线程
for(int i=0;i<100000;i++){
Thread.sleep(200);
System.out.println("main"+i);
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
day2
(1)、进程中的多任务
(2)、MyThread extends Thread{
//指定线程的运行体
public void run(){...}
}
Thread t = new MyThread();
t.start();
Thread.sleep();//让当前线程挂起
(3)、线程的状态及其转换
block-->running-->ready--->running
(4)、守护线程
通过setDaemon方法，可以设置线程为守护线程。JVM如果发现当前的线程全部是守护线程时，就退出。
import java.util.Date;
public class MyThread extends Thread {
// 重写Thread的run方法
// 用于指定线程的运行体
@Override
public void run() {
while (true) {
System.out.println(new Date());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
}
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
Thread t=new MyThread();
//设置为守护线程，默认为fales；
t.setDaemon(true);
t.start();
System.out.println("Main");
System.in.read();
}
}
(5)、Runnable接口
方法1）、Thread t = new MyThread();
//MyThread 是Thread的子类
小程序（麻烦的例子，非Runnable例子）
public class MyThread extends Thread {
private NameList nameList;
public MyThread(NameList nameList){
this.nameList=nameList;
}
// 重写Thread的run方法
// 用于指定线程的运行体
@Override
public void run() {
while (true) {
try {
//打印集合中的内容
nameList.printNames();
Thread.sleep(5000);
} catch (InterruptedException e) {
}
}
}
}
＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class NameList {
private List
public void addName(String name){
nameList.add(name);
}
public void printNames(){
System.out.println(nameList);
}
public static void main(String[] args) throws Exception {
NameList nameList=new NameList();
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
Thread t=new MyThread(nameList);
t.setDaemon(true);
t.start();
String str;
while((str=br.readLine())!=null){
if(str.equalsIgnoreCase("exit")){
break;
}
nameList.addName(str);
}
}
}
方法2）、Thread t = new Thread(r);
其中r为实现了Runnable接口的类的对象
class SomeClass
implements Runnable{
Public void run(){.........}
}
SomeClass sc = new SomeClass()
Thread t = new Thread(sc)
t.start();
//线程的运行体是sc的run方法
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class NameList implements Runnable{
private List
public void addName(String name){
nameList.add(name);
}
public void printNames(){
System.out.println(nameList);
}
public void run() {
while (true) {
try {
//打印集合中的内容
printNames();
Thread.sleep(5000);
} catch (InterruptedException e) {
}
}
}
public static void main(String[] args) throws Exception {
NameList nameList=new NameList();
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
Thread t=new Thread(nameList);
t.setDaemon(true);
t.start();
String str;
while((str=br.readLine())!=null){
if(str.equalsIgnoreCase("exit")){
break;
}
nameList.addName(str);
}
}
}
方法3）、内部类－－－以后再说
(6)、线程安全问题
两个以上的线程访问同一个可变对象。
加锁
synchronized (obj) {
语句块;//obj为Object的任意对象，用obj作为唯一锁来加锁。有多个synchronized(??)的时候，如果都用obj的话，相当于只有obj一条钥匙。如果除了obj还有其他如obj1的情况下，obj加锁的不防碍obj1的锁。
}
public void f(){synchronized(this/*必须是this并且已把这个线程需要的方法的所有代码都包括起来*/){......}} 等价于 public synchronized void f(){.........}
(7)、常见的线程安全的类和线程不安全的类
String //不可变类，线程安全
Integer Double... //不可变类，线程安全
StringBuffer //线程安全，相当于StringBuilder加了synchronized
StringBuilder //线程不安全，通常用于单线程，加锁会阻碍代码的执行速度
ArrayList //线程不安全，所有集合类（除了Vector 、Hashtable）都是线程不安全
HashSet //线程不安全
HashMap //线程不安全
Vector //线程安全（JDK1.1老版本开始出现）
特别例子：优化代码
Vector vector=....
int size = vector.size();//优化语句，只调用一次Vecto加快代码执行速度
for(int i=0;i<size/*vector.size()*/;i++){...}//for循环因为多次调用Vector会因为加锁的问题影响代码执行速度
Hashtable //线程安全（JDK1.1老版本开始出现）
(8)、了解一下Thread类基本方法
Thread t;
t.getName(name);
t.getId();
t.setName();
t.setPriority(newPriority);
t.getPriority();
Thread.MAX_PRIORITY
Thread.MIN_PRIORITY
Thread t=Thread.currentThread();//获取当前线程的优先级
Thread.sleep();
