(1)
package day20150907thread;
/**
* 线程调度分配给cpu的时间片段给不同的线程
* 得到时间片段的线程被cpu运行,其他线程等待
* 线程调度会尽可能均匀的分配时间片段给不同的进程
*
* 经纪人分配给剧组不同的档期,让葛大爷去演戏
* 线程调度分配给不同的线程时间片段,让cpu去运行
*/
public class ThreadDemo1 {
/**
* 第一种创建线程的方式
* 继承Thread类,重写run方法
*
* 写起来简单,但用起来没有实现Runnable灵活
*/
public static void main(String[] args) {
//有先后顺序的运行方式叫同步运行(同一个线程)
//各干各的叫异步运行(多个线程里执行)
Thread t1 = new Thread1();
Thread t2 = new Thread2();
/**
* start方法用于将线程纳入线程调度
* 这时,线程处于runnable状态
* 等待线程调度分配时间片段
* 当线程调度将时间片段给配给当前线程
* 该线程的run方法才被执行
* 直到run方法执行完毕,线程结束最终被回收
* 在线程的run方法执行期间,该线程处于走走停停
*/
t1.start();
t2.start();
}
}
//Thread:实现类,已经实现Runnable接口
class Thread1 extends Thread{
@Override
public void run() {
for(int i=0;i<5000;i++){
System.out.println("谁啊");
}
}
}
class Thread2 extends Thread{
@Override
public void run(){
for(int i=0;i<5000;i++){
System.out.println("我");
}
}
}
(2)
package day20150907thread;
/**
* 第二种创建线程方式:
* 定义线程体Runnable
*/
public class ThreadDemo2 {
public static void main(String[] args) {
Runnable r1 = new MyRunnable1();
Runnable r2 = new MyRunnable2();
// r1.run();
// r2.run();
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}
class MyRunnable1 implements Runnable{
@Override
public void run() {
for(int i=0;i<5000;i++){
System.out.println("谁啊?");
}
}
}
class MyRunnable2 implements Runnable{
@Override
public void run() {
for(int i=0;i<5000;i++){
System.out.println("我");
}
}
}
(3)
package day20150907thread;
public class ThreadDemo3 {
/**
* 使用匿名内部类的方式创建线程
*/
public static void main(String[] args) {
Thread t1 = new Thread(){
public void run(){
for(int i=0;i<5000;i++){
System.out.println("11111111111");
}
}
};
Thread t2 = new Thread(
new Runnable(){
public void run(){
for(int i=0;i<5000;i++){
System.out.println("22");
}
}
}
);
t1.start();
t2.start();
}
}
(4)
package day20150907thread;
/**
* 获取执行当前代码片段的线程
* 可以调用Thread提供的静态方法
* Thread Thread.currentThread()
*/
public class ThreadDemo4 {
public static void main(String[] args) {
Thread current = Thread.currentThread();
System.out.println("main线程:"+current);
testCurrentThread();
Thread t1 = new Thread(){
public void run(){
Thread myt = Thread.currentThread();
System.out.println("myt:"+myt);
testCurrentThread();
}
};
t1.start();
}
public static void testCurrentThread(){
Thread t = Thread.currentThread();
System.out.println("方法线程:"+t);
}
}
(5)
package day20150907thread;
/**
* ID:非空并且唯一
* 线程其他API
*/
public class ThreadDemo5 {
public static void main(String[] args) {
//获取调用main方法的相关信息
Thread t = Thread.currentThread();
//获取线程id,通常由系统分配
long id = t.getId();
System.out.println("ID"+id);
/**
* 获取线程名字
* 格式为Thread-X
* 但是main方法的线程不是这个,为main
*/
String name = t.getName();
System.out.println("线程名字:"+name);//main
int p = t.getPriority();
System.out.println("线程优先级:"+p);
System.out.println("线程状态"+t.getState());
System.out.println("线程是否活着:"+t.isAlive());
System.out.println("是否后台进程:"+t.isDaemon());
System.out.println("线程是否被中断:"+t.isInterrupted());
}
}
(6)
package day20150907thread;
/**
* 线程优先级
* 1-10
* 理论上,线程优先级高的线程
* 被分配的时间片段次数多
*/
public class ThreadDemo6 {
public static void main(String[] args) {
Thread max = new Thread(){
public void run(){
for(int i=0;i<5000;i++){
System.out.println("maxmaxmaxmaxmaxmaxmaxmax");
}
}
};
Thread min = new Thread(){
public void run(){
for(int i=0;i<5000;i++){
System.out.println("min");
}
}
};
Thread nor = new Thread(){
public void run(){
for(int i=0;i<5000;i++){
System.out.println("normal");
}
}
};
max.setPriority(Thread.MAX_PRIORITY);//或者max.setPriority(10);
min.setPriority(Thread.MIN_PRIORITY);//或者min.setPriority(1);
max.start();
min.start();
nor.start();
}
}
(7)
package day20150907thread;
/**
* 后台线程(守护线程)
* 当进程中的所有前台线程都结束时,后台线程结束
* 无论后台线程是否还在运行
*/
public class ThreadDemo7 {
public static void main(String[] args) {
//rose:前台进程
Thread rose = new Thread(){
public void run(){
for(int i=0;i<8;i++){
System.out.println("Go");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
//jack:守护进程
Thread jack = new Thread(){
public void run(){
while(true){
System.out.println("Jack: you go, I go!");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
rose.start();
jack.setDaemon(true);
jack.start();
//while(true);//此死循环没执行完的话,main方法不结束,守护进程也不结束
//main方法执行完
System.out.println("main方法执行完了");
}
}
(8)
package day20150907thread;
import java.text.SimpleDateFormat;
import java.util.Date;
//(8)sleep 阻塞
public class ThreadDemo8 {
/**
* 实现电子表(15:13:24)
*/
public static void main(String[] args) {
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
while(true){
Date now = new Date();
System.out.println(sdf.format(now));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
(9)
package day20150907thread;
/**
* join:线程同步
*
* 注:
* 解决多线程并发安全问题的办法是:
* 将异步的操作变成同步的
*
* 产生多线程并发的原因是:
* 多线程并发操作同一数据
*/
public class ThreadDemo9 {
/**
* 图片是否下载完
*/
public static boolean isFinish;
public static void main(String[] args) {
final Thread download = new Thread(){
public void run(){
System.out.println("开始下载图片。。。");
for(int i=1;i<=100;i++){
System.out.println(i+"%");
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("下载完成");
isFinish = true;
}
};
/*
* main方法中定义了一个内部类show
* 该内部类中若想引用main方法中的其他局部变量
* 那么这个变量必须是final的
*/
Thread show = new Thread(){
public void run(){
System.out.println("开始显示图片");
//这里等待图片下载完成
try {
download.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
if(!isFinish){
throw new RuntimeException("图片还没有下载完成");
}
System.out.println("图片打开");
}
};
download.start();
show.start();
}
}