摘要：本文讲解了Java中线程的使用，包括线程概念、线程同步、等内容
一、线程概念：
- 有序严谨的指令集称为程序
- 程序的同时多运行称为线程
- 程序中不同的执行路径称为线程
- 多线程编程简单、效率高、易于资源共享
二、线程同步
- 线程同步指的是在一段程序执行过程中，无论成功还是失败，其他线程都会等待该线程执行完毕，才会转入其他线程。这样可以保证程序的完整性和安全性。
三、例子与说明
//实现代码
// 此程序用来练习使用线程!
//Version:1.0
//@Author:Yongchun_zha
package cha06;
//第一种方法创建线程
class Xc extends Thread//创建线程所需要继承的类
{
public void run()//run方法是覆盖父类的一个方法
{
for(int i=0;i<20;i++)
{
System.out.println("子函数");
}
}
}
public class L6_1
{
public static void main(String[] args)
{
Xc xc=new Xc();
xc.start();//创建一个线程
//注：谁调用的start方法，他就会去自动调用run方法；
// start会单开启一个线程，而不是直接调用,程序同时往下执行
for(int i=0;i<20;i++)
{
System.out.println("主函数");
}
}
}
//第二种方法创建线程(推荐方法)
class Xc2 implements Runnable//不继承类，而是直接实现接口
{
public void run()
{
for(int i=0;i<20;i++)
{
System.out.println("子函数");
}
}
}
public class L6_1
{
public static void main(String[] args)
{
Xc2 xc2=new Xc2();
Thread a=new Thread(xc2);
a.start();
for(int i=0;i<20;i++)
{
System.out.println("主函数");
}
}
}
//此程序用来练习使用线程!
//Version:1.0
//@Author:Yongchun_zha
package cha06;
//第一种方法创建线程
class Xc extends Thread//创建线程所需要继承的类
{
public void run()//run方法是覆盖父类的一个方法
{
for(int i=0;i<20;i++)
{
System.out.println("子函数");
}
}
}
//练习线程功能:设定线程名称
class Xc3 extends Thread
{
public void run()
{
System.out.println(Thread.currentThread()+"is running");//显示当前线程名称
}
}
public class L6_1
{
public static void main(String[] args)
{
Xc3 xc1=new Xc3();
xc1.setName("线程一");
xc1.start();
Xc3 xc2=new Xc3();
xc2.setName("线程二");
xc2.start();
Xc3 xc3=new Xc3();
xc3.setName("线程三");
xc3.start();
System.out.println(Thread.currentThread()+"is running");
}
}
//线程练习：设置线程优先级
public class L6_1
{
public static void main(String[] args)
{
Thread a1=new Thread(new Xc41());
Thread a2=new Thread(new Xc42());
a1.setPriority(Thread.NORM_PRIORITY+5);//设置线程优先级，默认级别为5，最多为10
a1.start();
a2.start();
}
}
class Xc41 implements Runnable//不继承类，而是直接实现接口
{
public void run()
{
for(int i=0;i<100;i++)
{
System.out.println("1线程"+i);
}
}
}
class Xc42 implements Runnable//不继承类，而是直接实现接口
{
public void run()
{
for(int i=0;i<100;i++)
{
System.out.println("第2个线程正在执行"+i);
}
}
}
//线程的睡眠
//注意：用throws抛异常的时候，如果向主调处抛异常的方法是从父类继承的或者是从接口实现的，
//那么，覆盖父类方法或实现接口方法时，如果父类方法中的原方法或接口中的原抽象方法没有抛异常，
//则子类覆盖父类的方法或实现接口的方法也不能抛异常。
//当出现这种情况时只能用try...catch方法
public class L6_1
{
public static void main(String[] args)
{
Thread xc5=new Thread(new Xc5());
xc5.start();
}
}
class Xc5 implements Runnable//不继承类，而是直接实现接口
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.println(Thread.currentThread()+" "+i);
try
{
Thread.sleep(1000);//睡眠1000毫秒
}
catch(Exception e)
{
System.out.println("执行有误！");
}
}
}
}
//线程的让步与阻塞
public class L6_1
{
public static void main(String[] args)
{
Thread xc61=new Thread(new Xc6());
Thread xc62=new Thread(new Xc6());
xc61.setName("线程一");
xc62.setName("线程二");
xc61.start();
xc62.start();
try
{
xc61.join();//线程的阻塞
//注：阻塞时将当前线程暂停，直至调用jion函数的线程执行完毕程序才继续往下执行
}
catch(Exception e)
{
}
for(int i=0;i<20;i++)
{
System.out.println("主线程"+i);
}
}
}
class Xc6 implements Runnable//不继承类，而是直接实现接口
{
public void run()
{
for(int i=1;i<10;i++)
{
System.out.println(Thread.currentThread().getName()+": "+i);
try
{
if(i%5==0)
{
Thread.yield();//线程让步
}
}
catch(Exception e)
{
System.out.println("执行有误！");
}
}
}
}//实例
//此程序用来实现一个简易的卖票流程!
//Version:1.0
//@Author:Yongchun_zha
package cha06;
public class L6_2
{
public static void main(String[] args)
{
Thread xc1=new Thread(new Xc());
Thread xc2=new Thread(new Xc());
xc1.start();
xc2.start();
}
}
class Xc implements Runnable
{
public static int chepiao=100;//注：static的作用是使得两个线程共用一个变量，而非分别使用
public static String aa=new String("1");
public void run()
{
while(true)
{
synchronized (aa) //即可以修饰代码块也可以修饰函数，其作用是让其所管辖的内容作为整体执行，当该函数饰函数时，不需要字符串，相当于默认this。
{
if(chepiao>0)
{
System.out.println("第"+Thread.currentThread().getName()+"个车站正在卖第"+(101-chepiao)+"张");
--chepiao;
}
else
{
break;
}
}
}
}
}
//此程序用来实现一个简易的生产消费流程!
//Version:1.0
//@Author:Yongchun_zha
package cha06;
public class L6_3
{
public static void main(String[] args)
{
Ck ck=new Ck();
Shengchan sc=new Shengchan(ck);
Xiaofei xf=new Xiaofei(ck);
Thread xc1=new Thread(sc);
xc1.start();
Thread xc2=new Thread(xf);
xc2.start();
}
}
//仓库类
class Ck
{
private char rl[]=new char[8];
private int wp=0;
public synchronized void shengchan(char aa)
{
while(wp==rl.length)
{
try
{
this.wait();
}
catch(Exception e){}
}
this.notify();//叫醒另一个进程，在当前进程就绪的前提下
rl[wp]=aa;
++wp;
System.out.println("生产线正在生产第 "+wp+" 个物品，该物品是： "+aa);
}
public synchronized void xiaofei()
{
char aa;
while(wp==0)
{
try
{
this.wait();
}
catch(Exception e){}
}
this.notify();
aa=rl[wp-1];
System.out.println("消费线程正在消费第 "+wp+" 个产品，该产品是： "+aa);
--wp;
}
}
//生产类
class Shengchan implements Runnable
{
private Ck ck=null;
public Shengchan(Ck ck)
{
this.ck=ck;
}
public void run()
{
char aa;
for(int i=0;i<26;i++)
{
aa=(char)('A'+i);
ck.shengchan(aa);
}
}
}
//消费类
class Xiaofei implements Runnable
{
private Ck ck=null;
public Xiaofei(Ck ck)
{
this.ck=ck;
}
public void run()
{
for(int i=0;i<26;i++)
{
ck.xiaofei();
}
}
}