【Java笔记】Thread

相关概念

线程是比进程更小的执行单位，也称作“轻量级进程”
线程是一个进程中独立的控制流，可以并发执行
自身没有入口和出口，不能自动运行，由进程启动执行，完成后自行终止
可以多个线程并发执行，Java平台的线程调度是抢占式的

基础方法

线程的互斥

Java中用关键字synchronized来为共享资源加锁

public class ThreadSync1{
public static void main(String args[])
{
Account a=new Account();
(new Deposit(a,100)).start();
(new Deposit(a,200)).start();
(new Withdraw(a,50)).start();
}
}

//账户 —— 可以进行存款，取款，查看余额
class Account
{
private String name;//账户人
private  int value;//账户金额
void put(int i)
{
value=value+i;
}
//取钱-如果钱不够就把当前账户金额取出
int get(int i)
{
if(value>i)
value=value-i;
else
{
i=value;
value=0;
}
return i;
}
int money()
{
return value;
}
}

//存款 —— 执行时锁定共享资源Account
class Deposit extends Thread
{
private Account a;
private  int amount;

public Deposit(Account a,int amount)
{
this.a=a;
this.amount=amount;
}
public void run()
{
synchronized(a)
{
int k=a.money();
try
{
sleep(1);
}
catch(InterruptedException e)
{
System.out.println(e);
}
a.put(amount);
System.out.println("现有"+k+",存入"+amount+",余额"+a.money());
}
}
}

//取款 —— 执行时锁定共享资源Account
class Withdraw extends Thread
{
private Account a;
private  int amount;
public Withdraw(Account a,int amount)
{
this.a=a;
this.amount=amount;
}

public void run()
{
synchronized(a)
{
int k=a.money();
try
{
sleep(1) ;
}
catch(InterruptedException e)
{
System.out.println(e);
}
System.out.println("现有"+k+",取走"+a.get(amount)+",余额"+a.money());
}
}
}

线程的同步

Java中通过用wait()方法和notify()方法来实现同步

public class ThreadSync2
{
public static void main(String args[])
{
Vector obj = new Vector();
Thread consumer = new Thread(new Consumer(obj));
Thread producter = new Thread(new Producter(obj));
consumer.start();
producter.start();
}
}

/*消费者 */
class Consumer implements Runnable
{
private Vector obj;
public Consumer(Vector v)
{
this.obj = v;
}
public void run()
{
synchronized(obj)
{
while (true)
{
try{
if (obj.size() ==0)
{
obj.wait();
}
System.out.println("Consumer:goods have been taken");
System.out.println("obj size: " + obj.size());
obj.clear();
obj.notify();
}
catch(Exception e) {
e.printStackTrace();
}
}
}
}
}

/*  生产者 */
class Producter implements Runnable {
private Vector obj;
public Producter(Vector v)
{
this.obj = v;
}
public void run()
{
synchronized(obj)
{
while (true)
{
try {
if (obj.size() !=0)
{
obj.wait();
}
obj.add(new String("apples"));
obj.notify();
System.out.println("Producter:obj are ready");
Thread.sleep(500);
}
catch(Exception e) {
e.printStackTrace();
}
}
}
}
}

小结

在主进程运行的前提下，自己再启动多个线程并行同时执行，我们程序的效率将会极大的提高。
在这里，可能出问题的就是多线程下操作公共资源会出错，所以我们可以采用锁的机制。
但是锁可能会引起死锁，多个线程循环等待，导致程序卡死，所以要认真设计。