Wsrtjtyk

I am able to send a mail using javax.mail API. But the problem here is on an average for each mail it taking around 4.3 seconds to send to destination.

If I am sending a 20 mails sequentially, it takes around 86.599 seconds. For my requirement this approach will not work. I am looking for an approach which can send large number of mails in less time.

When I looked at the debug log, the API is trying to authenticate to SMTP server for each and every message it sending. But I am creating a session only one time and using the same session for all the mails I am sending. Now my question is Isn't it a overhead process every time authenticating itself to the smtp server. Isn't there a better approach ?

Below is the log trace you may find helpful.

250-AUTH LOGIN PLAIN XOAUTH XOAUTH2

250 ENHANCEDSTATUSCODES

DEBUG SMTP: Found extension "SIZE", arg "35882577"

DEBUG SMTP: Found extension "8BITMIME", arg ""

DEBUG SMTP: Found extension "AUTH", arg "LOGIN PLAIN XOAUTH XOAUTH2"

DEBUG SMTP: Found extension "ENHANCEDSTATUSCODES", arg ""

DEBUG SMTP: Attempt to authenticate

DEBUG SMTP: check mechanisms: LOGIN PLAIN DIGEST-MD5 NTLM 

DEBUG SMTP: AUTH LOGIN command trace suppressed

DEBUG SMTP: AUTH LOGIN succeeded

Please let me know your thoughts on this and any help on this is really appreciated.

-Narendra

How are you sending the messages? The JavaMail FAQ suggests that the static Transport.send method will open a fresh connection for each message, as it is a convenience method that creates a suitable Transport instance, connects it, calls sendMessage and then closes the connection again. If you get your own Transport instance from the Session you can connect once, then call sendMessage repeatedly to send several messages on the one connection, and finally close it. Something along the lines of (untested):

Transport t = session.getTransport();

t.connect();

try {

  for(Message m : messages) {

    m.saveChanges();

    t.sendMessage(m, m.getAllRecipients());

  }

} finally {

  t.close();

}

I got the same requirement at work. I must send bulk emails and standalone email. I do not find simple and satisfactory answer: bulk emails can be sent using a single connection but standalone email cannot until I create an asynchronous buffering to send emails in batch.

Last but not least, using a lot of Transport connection in a short time can lead to a no more socket handles are available because all ports are stuck in the TIME_WAIT state.

I finally conclude the best will be an SMTP connection pool and because no library exists (at least free) I create mine using Apache Common Pool and Java Mail:

//Declare the factory and the connection pool, usually at the application startup

SmtpConnectionPool smtpConnectionPool = new SmtpConnectionPool(SmtpConnectionFactoryBuilder.newSmtpBuilder().build());



//borrow an object in a try-with-resource statement or call `close` by yourself

try (ClosableSmtpConnection transport = smtpConnectionPool.borrowObject()) {

    MimeMessage mimeMessage = new MimeMessage(session);

    MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage, false);

    mimeMessageHelper.addTo("to@example.com");

    mimeMessageHelper.setFrom("from@example.com");

    mimeMessageHelper.setSubject("Hi!");

    mimeMessageHelper.setText("Hello World!", false);

    transport.sendMessage(mimeMessage, mimeMessage.getAllRecipients());

}



//Close the pool, usually when the application shutdown

smtpConnectionPool.close();

No idea if the standard Java mail API allows what you are trying to accomplish (session reuse), but you may consider using multi-threading:

I would use a ThreadPool and submit mail send jobs to it. Then you do any error handling / resending within the job class code, which is executed by the ThreadPool asynchronously, and your main thread can resume to do other things. Submitting a job will only take milliseconds. It been a while since I implemented something with thread pools in Java, but I remember it was fairly easy and straightforward. If you Google "Java ThreadPool" you find plenty of material.

You can use Thread pooling as it gives very good performance.I have implemented and sharing you the below code snippet.

try  {

    ExecutorService executor = Executors.newFixedThreadPool("no. of threads"); // no. of threads is depend on your cpu/memory usage it's better to test with diff. no. of threads.

    Runnable worker = new MyRunnable(message); // message is the javax.mail.Message

    executor.execute(worker);

    executor.shutdown();

    executor.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);

}