当我使用 a 单独调用某个方法时，它平均需要 11523 纳秒(对于 10000 次调用)，但是当我从另一个类的上下文中调用它时，它需要大约 95721 纳秒
方法体是
public static byte [] validateRequest(KARPPacket karpPacket)
{
try {
long before,time;
before =System.nanoTime();
byte [] encryptedTicket=karpPacket.getTicket();
byte[] decryptedTicket=null;
if(encryptedTicket==null)
return null;
if(encryptedTicket.length%16==0)
{
decryptedTicket = Encryptor.decrypt(encryptedTicket, ClientWindow.getSecretKey());
time=System.nanoTime()-before;
System.out.println(time);
if(karpPacket.getSenderProtocolAddressAsString().equals(getSrcAddressFromTicket(decryptedTicket)))
{
ClientTicketManager.getArpCash().put(karpPacket.getSenderProtocolAddressAsString(), karpPacket.getSenderHardwareAddressFormatted());
return decryptedTicket;
}
return decryptedTicket;
}
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
为什么会这样以及如何提高其性能。 我希望这足够的代码
这是 encryptor.decrypt 方法
public static byte[] decrypt(byte [] encryptedByteArray,String keyString)throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException
{
SecretKey key=loadKey(keyString);
byte[] clearByteArray;
Cipher dCipher=Cipher.getInstance("AES");
dCipher.init(Cipher.DECRYPT_MODE,key );
clearByteArray=dCipher.doFinal(encryptedByteArray);
return clearByteArray;
}
和加载键
public static SecretKey loadKey(String keyString) {
byte[] encoded = keyString.getBytes();
SecretKey key = new SecretKeySpec(encoded, "AES");
return key;
}
运行验证请求方法的其他上下文
package karp.client;
import java.awt.Color;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.sql.Timestamp;
import java.util.Date;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.swing.JOptionPane;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyledDocument;
import karp.client.presentation.ClientWindow;
import karp.client.util.Constants;
import karp.generalutil.common.Encryptor;
import karp.generalutil.destination.TicketDestination;
import karp.packet.KARPPacket;
public class KARPMessageHandlerP {
String localIpAddress=null;
ClientTicketManager clientTicketManager;
KARPSender karpRequestSender=new KARPSender();
byte [] srcMac;
NetworkInterface network;
public KARPMessageHandlerP(KARPPacket karpPacket)
{
try
{
long before,time;
localIpAddress=KARPReciever.localIpAddress;
clientTicketManager=KARPReciever.clientTicketManager;
srcMac = KARPReciever.srcMac;
//
if(karpPacket.getOperation()==KARPPacket.ARP_REPLY)
{
if(karpPacket.getSenderProtocolAddressAsString().equals(localIpAddress))//request sent by client
{
// if the reply was sent by the client no action must be taken.
}
else
{
if(karpPacket.getTargetProtocolAddressAsString().equals(localIpAddress))
{
byte [] ticket=karpPacket.getTicket();
if(ticket==null)
{
//delete the new entry from cash and refresh the cash
deleteEntry(karpPacket.getSenderProtocolAddressAsString());
}
else
{
if(validateReply(karpPacket) )
{
}
else
{
deleteEntry(karpPacket.getSenderProtocolAddressAsString());
//delete entry and refresh cash
}
}
}
}
}
else
if(karpPacket.getOperation()==KARPPacket.ARP_REQUEST)
{
if(karpPacket.getSenderProtocolAddressAsString().equals(localIpAddress))//request sent by client
{
//1
if(karpPacket.getTicket()!=null)
{
//custom request no need to add;
}
//2
else //new request need to add ticket
{
String destinationId=(karpPacket.getTargetProtocolAddressAsString());
// if the map contain ticket to destination add the ticket directly
//2-1
KARPPacket customKarpPacket;
byte [] ticketDestinationByte=null;
if(ClientTicketManager.getDestinationTicketMap().containsKey(destinationId))
{
ticketDestinationByte=ClientTicketManager.getDestinationTicketMap().get(destinationId);
}
//2-2 send ticket request
else
{
ticketDestinationByte=clientTicketManager.getDestinationTicket(destinationId);
}
if(ticketDestinationByte!=null)
{
customKarpPacket= karpRequestSender.createKARPPacket(karpPacket.getDstAddress(), karpPacket.getSrcAddress(),
InetAddress.getLocalHost().getAddress(), karpPacket.getTargetProtoAddr(),
karpPacket.getTargetHardAddr(),
ticketDestinationByte, KARPPacket.ARP_REQUEST);
karpRequestSender.sendKARPPacket(customKarpPacket);
}
}
}
else
{
if(karpPacket.getTargetProtocolAddressAsString().equals(localIpAddress))//check to see if the request is for the client
{
byte [] ticketRequest=validateRequest(karpPacket);
if(ticketRequest!=null)
{
//reply to the request;
String sessionKey=getSessionKeyFromTicket(ticketRequest);
TicketDestination ticketDestination=new TicketDestination();
ticketDestination.setDestinationId(karpPacket.getSenderProtocolAddressAsString());
ticketDestination.setSourceId(karpPacket.getTargetProtocolAddressAsString());
ticketDestination.setSourceDestinationKey(sessionKey);
byte [] ticketDestinationByte=ticketDestination.getAsByte();
byte [] encryptedTicketDestination=Encryptor.encrypt(ticketDestinationByte, sessionKey);
///need to review target hardware address
KARPPacket karpPacketReply=karpRequestSender.createKARPPacket(karpPacket.getSrcAddress(), srcMac, InetAddress.getLocalHost().getAddress(), karpPacket.getSenderProtoAddr(),karpPacket.getSrcAddress(), encryptedTicketDestination, KARPPacket.ARP_REPLY);
karpRequestSender.sendKARPPacket(karpPacketReply);
}
else //delete ticket invalid request
{
deleteEntry(karpPacket.getSenderProtocolAddressAsString());
}
}
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
//System.out.println(timeConsumed);
}
public static byte [] validateRequest(KARPPacket karpPacket)
{
try {
long before,time;
before =System.nanoTime();
byte [] encryptedTicket=karpPacket.getTicket();
byte[] decryptedTicket=null;
if(encryptedTicket==null)
return null;
if(encryptedTicket.length%16==0)
{
decryptedTicket = Encryptor.decrypt(encryptedTicket, ClientWindow.getSecretKey());
time=System.nanoTime()-before;
System.out.println(time);
if(karpPacket.getSenderProtocolAddressAsString().equals(getSrcAddressFromTicket(decryptedTicket)))
{
ClientTicketManager.getArpCash().put(karpPacket.getSenderProtocolAddressAsString(), karpPacket.getSenderHardwareAddressFormatted());
return decryptedTicket;
}
return decryptedTicket;
}
return null;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public boolean validateReply(KARPPacket karpPacket) throws InvalidKeyException, NoSuchAlgorithmException,
NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException
{
// KARPReciever.stop=true;
// for(int i=0;i<10000;i++)
// {
String sessionKey;
byte[] encryptedTicket=karpPacket.getTicket();
if(ClientTicketManager.getDestinationKeyMap().containsKey(karpPacket.getSenderProtocolAddressAsString()))
{
sessionKey=ClientTicketManager.getDestinationKeyMap().get(karpPacket.getSenderProtocolAddressAsString());
byte[] decryptedTicket=Encryptor.decrypt(encryptedTicket, sessionKey);
if(karpPacket.getSenderProtocolAddressAsString().equals(getSrcAddressFromTicket(decryptedTicket)))
{
ClientTicketManager.getArpCash().put(karpPacket.getSenderProtocolAddressAsString(), karpPacket.getSenderHardwareAddressFormatted());
// after=System.nanoTime();
// timeConsumed=(after-before);
// System.out.print("kl"+timeConsumed);
return true;
}
}
//}
return false;
}
public void deleteEntry(String entryIpAddress)
{
try
{
if(!ClientTicketManager.getAuthenticatedUser().contains(entryIpAddress))
{
if(ClientTicketManager.getArpCash().containsKey(entryIpAddress))
{
String updateCommand="arp -s "+entryIpAddress+" "+clientTicketManager.getArpCash().get(entryIpAddress);
//printCash();
Runtime.getRuntime().exec(updateCommand);
}
else
{
String deleteCommand ="arp -d "+entryIpAddress;
Runtime.getRuntime().exec(deleteCommand);
}
}
}
catch(Exception e)
{
}
}
public static String getSrcAddressFromTicket(byte [] ticket)
{
byte [] srcByte=new byte[4];
System.arraycopy(ticket, 16, srcByte, 0, 4);
String srcString=TicketDestination.getIpAddressAsString(srcByte);
return srcString;
}
public String getSessionKeyFromTicket(byte [] ticket)
{
byte [] sessionKeyByte=new byte[16];
System.arraycopy(ticket, 0, sessionKeyByte,0, 16);
return new String(sessionKeyByte);
}
public void printCash()
{
for(Object entry:ClientTicketManager.getArpCash().entrySet().toArray())
{
System.out.println(entry+" "+clientTicketManager.getArpCash().get(entry)+" entry in cash ");
}
}
}
最佳答案
当您预热代码时，它会变得更快，具体取决于代码的使用方式。
第一次运行它时，它非常慢，它必须加载类并初始化它们。
当您重复运行代码时，它不仅会预热代码并触发编译它的部分，而且缓存中的温度也会升高，例如L1 访问比主内存访问快 100 倍。
如果您运行代码 10K 或 20K 次，所有代码都将被编译并在缓存中预热，并且分支预测运行良好。
即使如此，如果您进行上下文切换并执行其他操作，您也会发现速度再次变慢，因为您的缓存不太热。您可以看到速度减慢了 2-5 倍。
顺便说一句，还有其他因素，例如资源瓶颈、CPU 自行断电以节省电量以及以较低的频率运行。
关于java - 方法的性能，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17134249/