Bitcoin Forum

Block.analyse() method:

Account generatorAccount = accounts.get(Account.getId(generatorPublicKey));
synchronized (generatorAccount) {
    generatorAccount.setBalance(generatorAccount.balance + totalFee * 100L);
    generatorAccount.setUnconfirmedBalance(generatorAccount.unconfirmedBalance + totalFee * 100L);
}

peers.toArray(new Peer[0])

peers.toArray(new Peer[peers.size()])

        static Peer getAnyPeer(int state, boolean applyPullThreshold) {

            synchronized (peers) {

                Collection<Peer> peers = ((HashMap<String, Peer>)Nxt.peers.clone()).values();
                Iterator<Peer> iterator = peers.iterator();
                while (iterator.hasNext()) {

                    Peer peer = iterator.next();
                    if (peer.blacklistingTime > 0 || peer.state != state || peer.announcedAddress.length() == 0 || (applyPullThreshold && enableHallmarkProtection && peer.getWeight() < pullThreshold)) {

                        iterator.remove();

                    }

                }

                if (peers.size() > 0) {

                    Peer[] selectedPeers = peers.toArray(new Peer[0]);
...

                List<Peer> selectedPeers = new ArrayList<>();
                for (Map.Entry<String, Peer> entry : peers.entrySet()) {
                    Peer peer = entry.getValue();
                    if (peer.blacklistingTime <= 0 && peer.state == state && peer.announcedAddress.length() != 0 && ((!applyPullThreshold || !enableHallmarkProtection || peer.getWeight() >= pullThreshold))) {
                        selectedPeers.add(peer);
                    }
                }

            List<Peer> selectedPeers = new ArrayList<Peer>();

            for (Peer peer : Nxt.peers.values()) {

                if (peer.blacklistingTime <= 0 && peer.state == state && peer.announcedAddress.length() > 0
                        && (!applyPullThreshold || !enableHallmarkProtection || peer.getWeight() >= pullThreshold)) {

                    selectedPeers.add(peer);

                }

            }

peers = ((HashMap<String, Peer>)Nxt.peers.clone()).values();

		static void loadBlocks(String fileName) throws Exception {
			
			FileInputStream fileInputStream = new FileInputStream(fileName);
			ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
			blockCounter = objectInputStream.readInt();
			blocks = (HashMap<Long, Block>)objectInputStream.readObject();
			lastBlock = objectInputStream.readLong();
			objectInputStream.close();
			fileInputStream.close();

    /**
     * Returns a {@link Collection} view of the values contained in this map.
     * The collection is backed by the map, so changes to the map are
     * reflected in the collection, and vice-versa.  The collection
     * supports element removal, which removes the corresponding
     * mapping from this map, via the <tt>Iterator.remove</tt>,
     * <tt>Collection.remove</tt>, <tt>removeAll</tt>,
     * <tt>retainAll</tt>, and <tt>clear</tt> operations.  It does not
     * support the <tt>add</tt> or <tt>addAll</tt> operations.
     *
     * <p>The view's <tt>iterator</tt> is a "weakly consistent" iterator
     * that will never throw {@link ConcurrentModificationException},
     * and guarantees to traverse elements as they existed upon
     * construction of the iterator, and may (but is not guaranteed to)
     * reflect any modifications subsequent to construction.
     */
    public Collection<V> values() {
        Collection<V> vs = values;
        return (vs != null) ? vs : (values = new Values());
    }

static byte[] convert(String string)

static String convert(byte[] bytes)

Here are a few more thoughts:

(1) This is a minor thing, but i don't think you're checking for overflow in any of the request parameters:
[code]
			int timestamp = ((Long)transactionData.get("timestamp")).intValue();
			short deadline = ((Long)transactionData.get("deadline")).shortValue();
			byte[] senderPublicKey = convert((String)transactionData.get("senderPublicKey"));
			long recipient = (new BigInteger((String)transactionData.get("recipient"))).longValue();
			int amount = ((Long)transactionData.get("amount")).intValue();

interface GetHandler
{
    bool canHandle(string requestType);
    void handle(response, request);
}

Account account = accounts.get(Account.getId(generatorPublicKey));

....

if (!Arrays.equals(generatorPublicKey, account.publicKey)) {
    return false;
}

        int version;
        int timestamp;
        long previousBlock;
        int numberOfTransactions;
        int totalAmount, totalFee;
        int payloadLength;
        byte[] payloadHash;
        byte[] generatorPublicKey;
        byte[] generationSignature;
        byte[] blockSignature;
        byte[] previousBlockHash;
        int index;
        long[] transactions;
        long baseTarget;
        int height;
        long nextBlock;
        BigInteger cumulativeDifficulty;

        byte type, subtype;
        int timestamp;
        short deadline;
        byte[] senderPublicKey;
        long recipient;
        int amount, fee;
        long referencedTransaction;
        byte[] signature;
        Attachment attachment;

        int index;
        long block;
        int height;

generatorAccount.setBalance(generatorAccount.balance + totalFee * 100L);
generatorAccount.setUnconfirmedBalance(generatorAccount.unconfirmedBalance + totalFee * 100L);

void setBalance(long balance) throws Exception {
    this.balance = balance;
    for (Peer peer : peers.values()) {
    if (peer.accountId == id && peer.adjustedWeight > 0) {
        peer.updateWeight();
    }
}

Transaction transaction = Transaction.getTransaction(buffer);
synchronized (Nxt.transactions) {						
    transaction.index = ++transactionCounter;						
}

catch (Exception e) { }

        synchronized long getBalance() {
            return balance;
        }

        synchronized long getUnconfirmedBalance() {
            return unconfirmedBalance;
        }

        void addToBalance(long amount) throws Exception {

            synchronized (this) {

                this.balance += amount;

            }

            updatePeerWeights();

        }
        
        void addToUnconfirmedBalance(long amount) throws Exception {

            synchronized (this) {

                this.unconfirmedBalance += amount;

            }

            updateUserUnconfirmedBalance();

        }

        void addToBalanceAndUnconfirmedBalance(long amount) throws Exception {

            synchronized (this) {

                this.balance += amount;
                this.unconfirmedBalance += amount;

            }

            updatePeerWeights();
            updateUserUnconfirmedBalance();

        }

Transaction transaction = Transaction.getTransaction(buffer);
transaction.index = transactionCounter.incrementAndGet();

            synchronized (this) {
                this.balance += amount;
                this.unconfirmedBalance += amount;
            }

			synchronized (account) {
								
				if (account.getUnconfirmedBalance() < amount * 100L) {
									
						doubleSpendingTransaction = true;
									
				} else {
									
						doubleSpendingTransaction = false;
									
						account.addToUnconfirmedBalance(- amount * 100L);
						
...

synchronized (this) {
    this.balance += amount;
}

						if (accumulatedAmount + amount <= accounts.get(sender).balance && transaction.validateAttachment()) {
							
							accumulatedAmounts.put(sender, accumulatedAmount + amount);
							
							newTransactions.put(transaction.getId(), transaction);
							payloadLength += transactionLength;
							
						}

			for (Map.Entry<Long, Transaction> transactionEntry : newTransactions.entrySet()) {
				
				Transaction transaction = transactionEntry.getValue();
				block.totalAmount += transaction.amount;
				block.totalFee += transaction.fee;
				block.payloadLength += transaction.getBytes().length;
				block.transactions[i++] = transactionEntry.getKey();
				
			}