Enlighten me with some Java Code

public class OracleJdbcTest
{
	String driverClass = "oracle.jdbc.driver.OracleDriver";

	Connection con;
	
	public void init(FileInputStream fs) throws ClassNotFoundException, SQLException, FileNotFoundException, IOException
	{
		Properties props = new Properties();
		props.load(fs);
		String url = props.getProperty("db.url");
		String userName = props.getProperty("db.user");
		String password = props.getProperty("db.password");
		Class.forName(driverClass);

		con=DriverManager.getConnection(url, userName, password);
	}
	
	public void fetch() throws SQLException, IOException
	{
		PreparedStatement ps = con.prepareStatement("select SYSDATE from dual");
		ResultSet rs = ps.executeQuery();
		
		while (rs.next())
		{
			// do the thing you do
		}
		rs.close();
		ps.close();
	}

	public static void main(String[] args) 
	{
		OracleJdbcTest test = new OracleJdbcTest();
		test.init();
		test.fetch();
	}
}

Enlilghtem me with some C Code

#include <linux/err.h>
#include <linux/delay.h>
#include <crypto/engine.h>
#include <uapi/linux/sched/types.h>
#include "internal.h"

#define CRYPTO_ENGINE_MAX_QLEN 10

/**
 * crypto_finalize_request - finalize one request if the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
static void crypto_finalize_request(struct crypto_engine *engine,
			     struct crypto_async_request *req, int err)
{
	unsigned long flags;
	bool finalize_cur_req = false;
	int ret;
	struct crypto_engine_ctx *enginectx;

	spin_lock_irqsave(&engine->queue_lock, flags);
	if (engine->cur_req == req)
		finalize_cur_req = true;
	spin_unlock_irqrestore(&engine->queue_lock, flags);

	if (finalize_cur_req) {
		enginectx = crypto_tfm_ctx(req->tfm);
		if (engine->cur_req_prepared &&
		    enginectx->op.unprepare_request) {
			ret = enginectx->op.unprepare_request(engine, req);
			if (ret)
				dev_err(engine->dev, "failed to unprepare request\n");
		}
		spin_lock_irqsave(&engine->queue_lock, flags);
		engine->cur_req = NULL;
		engine->cur_req_prepared = false;
		spin_unlock_irqrestore(&engine->queue_lock, flags);
	}

	req->complete(req, err);

	kthread_queue_work(engine->kworker, &engine->pump_requests);
}

/**
 * crypto_pump_requests - dequeue one request from engine queue to process
 * @engine: the hardware engine
 * @in_kthread: true if we are in the context of the request pump thread
 *
 * This function checks if there is any request in the engine queue that
 * needs processing and if so call out to the driver to initialize hardware
 * and handle each request.
 */
static void crypto_pump_requests(struct crypto_engine *engine,
				 bool in_kthread)
{
	struct crypto_async_request *async_req, *backlog;
	unsigned long flags;
	bool was_busy = false;
	int ret;
	struct crypto_engine_ctx *enginectx;

	spin_lock_irqsave(&engine->queue_lock, flags);

	/* Make sure we are not already running a request */
	if (engine->cur_req)
		goto out;

	/* If another context is idling then defer */
	if (engine->idling) {
		kthread_queue_work(engine->kworker, &engine->pump_requests);
		goto out;
	}

	/* Check if the engine queue is idle */
	if (!crypto_queue_len(&engine->queue) || !engine->running) {
		if (!engine->busy)
			goto out;

		/* Only do teardown in the thread */
		if (!in_kthread) {
			kthread_queue_work(engine->kworker,
					   &engine->pump_requests);
			goto out;
		}

		engine->busy = false;
		engine->idling = true;
		spin_unlock_irqrestore(&engine->queue_lock, flags);

		if (engine->unprepare_crypt_hardware &&
		    engine->unprepare_crypt_hardware(engine))
			dev_err(engine->dev, "failed to unprepare crypt hardware\n");

		spin_lock_irqsave(&engine->queue_lock, flags);
		engine->idling = false;
		goto out;
	}

	/* Get the fist request from the engine queue to handle */
	backlog = crypto_get_backlog(&engine->queue);
	async_req = crypto_dequeue_request(&engine->queue);
	if (!async_req)
		goto out;

	engine->cur_req = async_req;
	if (backlog)
		backlog->complete(backlog, -EINPROGRESS);

	if (engine->busy)
		was_busy = true;
	else
		engine->busy = true;

	spin_unlock_irqrestore(&engine->queue_lock, flags);

	/* Until here we get the request need to be encrypted successfully */
	if (!was_busy && engine->prepare_crypt_hardware) {
		ret = engine->prepare_crypt_hardware(engine);
		if (ret) {
			dev_err(engine->dev, "failed to prepare crypt hardware\n");
			goto req_err;
		}
	}

	enginectx = crypto_tfm_ctx(async_req->tfm);

	if (enginectx->op.prepare_request) {
		ret = enginectx->op.prepare_request(engine, async_req);
		if (ret) {
			dev_err(engine->dev, "failed to prepare request: %d\n",
				ret);
			goto req_err;
		}
		engine->cur_req_prepared = true;
	}
	if (!enginectx->op.do_one_request) {
		dev_err(engine->dev, "failed to do request\n");
		ret = -EINVAL;
		goto req_err;
	}
	ret = enginectx->op.do_one_request(engine, async_req);
	if (ret) {
		dev_err(engine->dev, "Failed to do one request from queue: %d\n", ret);
		goto req_err;
	}
	return;

req_err:
	crypto_finalize_request(engine, async_req, ret);
	return;

out:
	spin_unlock_irqrestore(&engine->queue_lock, flags);
}

static void crypto_pump_work(struct kthread_work *work)
{
	struct crypto_engine *engine =
		container_of(work, struct crypto_engine, pump_requests);

	crypto_pump_requests(engine, true);
}

medium blog

Lorem ipsum dolor sit amet, est idque noluisse indoctum ei, impetus accumsan evertitur at sed. Per saperet dolores ne, cu dolor adipiscing sea. Ut est erat iracundia. Pertinax scriptorem cum no? Decore vivendum nominati usu ne, ad labore singulis eam!

Some caption matching image content

Deserunt splendide quo eu, te illud possit quaestio his? Ei eam putent dolores. Tamquam sapientem ut nec, cu suas cibo eam? Graece habemus consequat te nam! An mei periculis quaerendum, gloriatur adolescens vim at, audiam aliquando ei mel. Fastidii mandamus honestatis et quo, unum delectus disputationi nec at, an homero vidisse vituperatoribus mea. Choro populo vix ut, ut has dicit fierent, augue nobis verterem id sea.

Has no volutpat dissentiet, no modo iudico usu, vidisse accusamus nam ei. Ius nostro oblique saperet no! Et vel virtute patrioque conceptam, mei vidit aliquip oportere no. Decore nullam sea eu, ut cum wisi feugait. Nobis necessitatibus vix cu, brute civibus at mel, usu no denique recteque mediocrem?

Another Heading

No delenit veritus assentior cum, alia erant graece mea an, mea ignota regione et. Ne meis tempor disputando mea, delenit vituperatoribus at vel. Falli corpora ea mel, dicit dissentiunt ea vis! At sumo enim phaedrum vis, option minimum mei ne, ne audiam aliquando vis. Cum cu stet eripuit imperdiet.

His scripta aperiri definitiones ne? Mea ne expetendis interesset, detracto indoctum argumentum ad quo, augue inani dolores his no? Et admodum deleniti nec. In timeam facilisi menandri vis? Probatus delicata accommodare id sea. Nam alia molestie voluptatibus te, eos nonumy inermis omittantur in, dolor soluta pericula an eam!

At sit essent blandit, eu pri aeque voluptaria. Facer aliquid similique an quo, etiam iracundia ei nec, ei repudiandae comprehensam pri. Bonorum fuisset sea te, ea inani mediocrem his, vis ei velit epicurei? Suas liberavisse ne cum, ad eam vocibus disputationi, et putant habemus detraxit vim.