Java程序每次运行至少启动两个线程：main线程、垃圾收集线程。
Thread类中常用的方法：
currentThread（静态），通过类名Thread直接调用；
判断线程是否启动（存活）
class MyThread implements Runnable{
public void run(){
for(int i=0;i<3;i++){
System.out.println(Thread.currentThread().getName()+"运行………"+i);
}
}
}
public class ThreadAliveDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t = new Thread(mt);
System.out.println("线程开始执行之前……"+t.isAlive());
t.start();
for(int i=0;i<5;i++){
System.out.println("等待……"+i);//i值的不同，最后运行结果不同
}
System.out.println("线程开始执行之后……"+t.isAlive());
for(int i=0;i<3;i++){
System.out.println("main运行……"+i);
}
System.out.println("代码执行之后……"+t.isAlive());
}
}
主线程有可能比其他行程先执行完，其他线程不会受到任何影响，不会随着主线程的结束而结束。
线程的强制执行
class MyThread implements Runnable{
public void run(){
for(int i=0;i<20;i++){
System.out.println(Thread.currentThread().getName()+"运行……"+i);
}
}
}
public class ThreadJoinDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t = new Thread(mt);
t.start();
for(int i=0;i<30;i++){
if(i>10){
try{
t.join();
}catch(Exception e){}
}
System.out.println("Main线程"+i);
}
}
}
线程的休眠：
sleep为静态方法，使用类名Thread直接调用
class MyThread implements Runnable{
public void run(){
for(int i=0;i<5;i++){
try{
Thread.sleep(1000);//每次输出都会间隔1000ms，达到延迟操作的结果
}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"…………"+i);
}
}
}
public class ThreadSleepDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(mt,"线程").start();
}
}
线程的中断：
class MyThread implements Runnable{
public void run(){
System.out.println("进入run方法");
try{
Thread.sleep(10000);
System.out.println("已完成休眠");
}catch(Exception e){
System.out.println("休眠被终止");
return;
}
System.out.println("正常结束");
}
}
public class ThreadInterruptDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t = new Thread(mt);
t.start();
try{
Thread.sleep(2000);
}catch(Exception e){}
t.interrupt();
}
}
在使用join和sleep时，要进行异常处理。
线程的礼让：
class MyThread implements Runnable{
public void run(){
for(int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"运行"+i);
if(i==2){
System.out.print("线程礼让：");
Thread.currentThread().yield();
}
}
}
}
public class ThreadYieldDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
Thread t1 = new Thread(mt,"线程A");
Thread t2 = new Thread(mt,"线程B");
t1.start();
t2.start();
}
}
每当线程满足条件（i=2）时，本线程就会停止，而让其他线程先执行。
同步：指多个操作在同一时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续进行。
解决资源共享的同步操作，可以使用同步代码块和同步方法两种方式完成。
同步代码块：
class MyThread implements Runnable{
private int ticket = 20;
public void run(){
for(int i=0;i<100;i++){
synchronized(this){ //将当前对象（this）设置成同步对象
if(ticket>0){
System.out.println(ticket--);
}
}
}
}
}
public class SynchronizedDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
}
}
同步方法：（使用synchronized关键字将一个方法声明为同步方法）
class MyThread implements Runnable{
private int ticket = 50;
public void run(){
for(int i=0;i<100;i++){
this.sale();
}
}
private synchronized void sale() {
if(ticket>0){
System.out.println(ticket--);
}
}
}
public class SynchronizedDemo {
public static void main(String[] args) {
MyThread mt = new MyThread();
new Thread(mt).start();
new Thread(mt).start();
new Thread(mt).start();
}
}
Java中方法定义的完整格式：
访问权限（public、default、protected、private）[final][static][synchronized]
返回值类型 void 方法名称（参数类型，参数名称）[throws Exception1,Exception2]
{
return 返回值；
}
死锁：指两个线程都在等着彼此先完成，造成了程序的停滞。
卖票：同一个动作处理同一资源
生产者消费者：不同动作处理同一资源
class Info{
private String name = "zhangsan";
private String content = "java";
private boolean flag = false;
public synchronized void set(String name,String content){
if(!flag){
try{
super.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
this.name = name;
this.content = content;
flag = false;
super.notify();
}
public synchronized void get(){
if(flag){
try{
super.wait();
}catch(InterruptedException e){
e.printStackTrace();
}
}
System.out.println(name+":"+content);
flag = true;
super.notify();
}
}
class Producer implements Runnable{
private Info info = null;
public Producer(Info info){
this.info = info;
}
public void run(){
boolean flag = false;
for(int i=0;i<10;i++){
if(flag){
this.info.set("zhangsan", "java");
flag = false;
}else{
this.info.set("wangzhi","www");
flag = true;
}
}
}
}
class Consumer implements Runnable{
private Info info = null;
public Consumer(Info info){
this.info = info;
}
public void run(){
for(int i=0;i<10;i++){
try{
Thread.sleep(100);
}catch(Exception e){
e.printStackTrace();
}
this.info.get();
}
}
}
public class ThreadCaseDemo {
public static void main(String[] args) {
Info i = new Info();
Producer pro = new Producer(i);
Consumer con = new Consumer(i);
new Thread(pro).start();
new Thread(con).start();
}
}
停止线程运行：在多线程开发中可以通过设置标志位的方式停止一个线程的运行。