创建线程
package com.company.create;
/**
*创建线程
*第一种方法：
*1.继承Thread类，重写run方法
*2.创建对象，启动线程：对象.start()
*/
public class Create1 extends Thread{
public static void main(String[] args) {
Create1 thread=new Create1();
thread.start();
}
@Override
public void run() {
super.run();
System.out.println("我是thread");
}
}package com.company.create;
/**
* 创建线程第二种方法：
* 1、实现Runnable接口 ,重写run方法
* 2、启动线程:实际是采用静态代理
* a)、创建真实角色
* b)、创建代理角色,代理角色持有真实角色的引用
* d)、代理角色.start()
*多个代理，共享一个真实角色的资源
*/
public class Create2 implements Runnable{
private int money=10;
@Override
public void run() {
for(int i=10;i>0;i--){
System.out.println("倒计时："+i);
System.out.println(Thread.currentThread().getName()+"查看了银行卡的钱："+money+"，但是每次查看后要扣一块手续费");
money--;
try {
Thread.currentThread().sleep(1000);//当前线程睡眠1秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Create2 realRole=new Create2();
Thread agencyRole=new Thread(realRole,"代理一号");
agencyRole.start();
new Thread(realRole,"代理二号").start();
new Thread(realRole,"代理三号").start();
}
}
package com.company.create;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
* Callable<Integer>
* 1、对外声明异常
* 2、可以存在返回值 创建线程的第三种方式
*
*/
public class Create3 implements Callable<Integer> {
private String name;
private int steps;
private long time;
private boolean flag=true;
public Create3() {
}
public Create3(String name, long time) {
super();
this.name = name;
this.time = time;
}
@Override
public Integer call() throws Exception {
while(flag){
Thread.sleep(time); //try..catch..
steps++;
}
return steps;
}
public void stop(){
this.flag= false;
}
/**
* @param args
* @throws InterruptedException
* @throws ExecutionException
*/
public static void main(String[] args) throws InterruptedException, ExecutionException {
//创建线程比较复杂
Create3 rabbit =new Create3("兔子",150);
Create3 tortoise =new Create3("王八",100);
//调度服务
ExecutorService ser =Executors.newFixedThreadPool(2);
//结果
Future<Integer> rabbitF =ser.submit(rabbit);
Future<Integer> tortoiseF =ser.submit(tortoise);
Thread.sleep(1000);
//停止
rabbit.stop();
tortoise.stop();
System.out.println("兔子"+rabbitF.get()+"步");
rabbitF.cancel(true);
if(rabbitF.isDone()){
System.out.println("over");
}
tortoiseF.cancel(true);
System.out.println("王八"+tortoiseF.get()+"步");
//停止服务
ser.shutdownNow();
}
}
线程的一些基本API
package com.company.info;
/**
* setName()
* getName()
* isAlive():线程的状态，线程已经启动但还没被终止，返回true，反之为false
* currentThread():当前运行的线程的引用
*/
public class Info {
public static void main(String[] args) {
InfoThread thread =new InfoThread();
Thread proxy =new Thread(thread,"a");
//所有的设置，建议在运行前 设置
proxy.setName("test");
Thread.currentThread().setName("maintest");
System.out.println("运行前的状态:"+proxy.isAlive());
proxy.start(); //就绪状态
System.out.println("start后的状态:"+proxy.isAlive());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread.stop();
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("结束的状态:"+proxy.isAlive());
}
}
class InfoThread implements Runnable{
private boolean flag =true;
@Override
public void run() {
int i=0;
while(flag){
System.out.println(Thread.currentThread().getName()+"-->"+i++);
}
}
public void stop(){
this.flag =false;
}
}
package com.company.info;
/**
*
* 线程的优先级: 只代表概率，不代表绝对先后顺序
* MIN_PRIORITY ： 1
* NORM_PRIORITY :5 默认优先级
* MAX_PRIORITY ：10
*
* getPriority()
* setPriority()
* 线程的优先级高度依赖于系统：
* 当虚拟机依赖于宿主机平台的线程实现机制时，java线程优先级就会被映射成宿主机平台的优先级
* 宿主机平台的优先级级别在数量上可能和java里的有些出入
* 如：window XP/NT有7个优先级级别，java的某些优先级将会映射到相同的操作系统优先级上
* 在Sun为Linux提供的虚拟机中，线程优先级被忽略，所有线程具有相同的优先级
*
*/
public class Info2 {
public static void main(String[] args) {
MyThread realRole1=new MyThread("a");
Thread proxy1=new Thread(realRole1);
MyThread realRole2=new MyThread("b");
Thread proxy2=new Thread(realRole2);
proxy1.setPriority(Thread.MAX_PRIORITY);
proxy2.setPriority(Thread.MIN_PRIORITY);
proxy2.start();
proxy1.start();
}
}
class MyThread implements Runnable{
String name;
boolean flag =true;
public MyThread() {
}
MyThread(String name){
this.name =name;
}
@Override
public void run() {
int i=0;
while(flag){
System.out.println(name +"-->"+i++);
}
}
public void stop(){
this.flag =false;
}
}
线程同步
锁对象
package com.company.synchronize;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 用锁对象ReentrantLock保护代码块
* myLock.lock();//ReentrantLock对象
* try{
* 关键部分
* }
* finally{
* lock.unlock();//即使发生异常，也要确保解锁
* }
* 这种结构保证任何时候只有一个线程能进入临界区
* 一旦一个线程锁住了锁对象，其他线程无法通过lock语句，其他线程调用lock时，则被阻塞，直到第一个线程释放锁
*/
public class TestReentrantLock {
public static void main(String[] args) {
B b=new B();
Thread proxy1=new Thread(b);
Thread proxy2=new Thread(b);
proxy1.start();
proxy2.start();
}
}
class B implements Runnable{
private static int j=100;
private Lock lock=new ReentrantLock();
@Override
public void run() {
lock.lock();//获取这个锁，若被其他线程调用则其他线程被阻塞
try{
for(int i=100;i>0;i--){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"--->"+j--+"-----i-----"+i);
}
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();
}
}
}
synchronized关键字
package com.company.synchronize;
public class TestSynchronized {
public static void main(String[] args) {
A a=new A();
Thread proxy1=new Thread(a);
Thread proxy2=new Thread(a);
proxy1.start();
proxy2.start();
}
}
class A implements Runnable{
private static int j=100;
@Override
public synchronized void run() {
for(int i=100;i>0;i--){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"--->"+j--+"-----i-----"+i);
}
}
}
再引用《core java》上的一个例子
一共三个类，模拟账号转账的，假设你有若干个账号，每个账号初始的金额都一样，让这些账号之间不停转账，下面实现的是同步的，总金额不会
关键在于锁和条件对象，可以去掉锁和条件对象比较差异，去掉后总金额会出现变少的情况
package com.company.synchronize;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class Bank {
private final double[] accounts;
private Condition sufficientFunds;
private final ReentrantLock reentrantLock;
/**
* 构造器
* @param n 账户的个数
* @param 每个账户的初始金额
*/
public Bank(int n, double initialBalance)
{
accounts = new double[n];
for (int i = 0; i < accounts.length; i++)
accounts[i] = initialBalance;
this.reentrantLock=new ReentrantLock();
sufficientFunds = reentrantLock.newCondition();//返回一个与该锁相关的条件对象
}
/**
* 从一个账户转账到另一个账户
* @param from 支出的账户
* @param to 收账的账户
* @param amount 转账的金额
*/
public void transfer(int from, int to, double amount)
{
reentrantLock.lock();
try{
//没有足够使其等待，等待其他进程转账过来
if(accounts[from] < amount)
{
//调用此方法，表示把该线程放到等待的条件集中，而自己无法解除阻塞，等待其他线程解除
sufficientFunds.await();
}
System.out.print(Thread.currentThread()+"----"+Thread.currentThread().getName());
accounts[from] -= amount;
System.out.printf(" %10.2f from %d to %d", amount, from, to);
accounts[to] += amount;
System.out.printf(" Total Balance: %10.2f%n", getTotalBalance());
sufficientFunds.signalAll();//解除所有等待此条件的线程的阻塞状态
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
reentrantLock.unlock();
}
}
/**
* 获得所有账户的总金额
* @return the total balance
*/
public double getTotalBalance()
{
reentrantLock.lock();
try{
double sum = 0;
for (double a : accounts)
sum += a;
return sum;
}finally{
reentrantLock.unlock();
}
}
/**
* 获得银行中的总账户数
* @return the number of accounts
*/
public int size()
{
return accounts.length;
}
}
package com.company.synchronize;
public class TransferRunnable implements Runnable{
private Bank bank;
private int fromAccount;
private double maxAmount;
private int DELAY = 10;
/**
* Constructs a transfer runnable.
* @param b bank对象
* @param from 支出的账户
* @param max 每次转账的最大金额
*/
public TransferRunnable(Bank b, int from, double max)
{
bank = b;
fromAccount = from;
maxAmount = max;
}
public void run()
{
try
{
while (true)
{
int toAccount = (int) (bank.size() * Math.random());
double amount = maxAmount * Math.random();
bank.transfer(fromAccount, toAccount, amount);
Thread.sleep((int)(DELAY*Math.random()));
}
}
catch (InterruptedException e)
{
}
}
}
package com.company.synchronize;
public class SynchBankTest {
public static final int NUMCOUNTS = 100;
public static final double INITIAL_BALANCE = 1000;
public static void main(String[] args)
{
Bank b = new Bank(NUMCOUNTS, INITIAL_BALANCE);
int i;
for (i = 0; i < NUMCOUNTS; i++)
{
TransferRunnable r = new TransferRunnable(b, i, INITIAL_BALANCE);
Thread t = new Thread(r);
t.start();
}
}
}
生产着消费者模式
package com.company.productconsumer;
public class Consumer implements Runnable{
private Factory factory;
public Consumer(Factory factory){
this.factory=factory;
}
@Override
public void run() {
for(int i=10;i>0;i--){
factory.consume();
}
}
}
package com.company.productconsumer;
public class Producer implements Runnable{
private Factory factory;
private String product;
public Producer(Factory factory,String product){
this.factory=factory;
this.product=product;
}
@Override
public void run() {
for(int i=10;i>0;i--){
factory.produce(product);
}
}
}
package com.company.productconsumer;
public class Factory {
private String product;
private boolean flag;//true表示可以消费，不可以生产，反之不可以消费，可以生产
//生产
public synchronized void produce(String product){
//不能生产，生产者等待
if(flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//生产
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("工厂生产了:"+product);
this.flag =true;
this.product =product;
this.notifyAll();
}
//消费
public synchronized void consume(){
if(!flag){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("工厂的:"+this.product+" 产品被消费了");
this.flag=false;
this.product=product;
this.notifyAll();
}
}
package com.company.productconsumer;
public class Test {
public static void main(String[] args) {
Factory product =new Factory();
new Thread(new Producer(product,"长得高护肤品")).start();
new Thread(new Consumer(product)).start();
}
}
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
